@algolia/monitoring 1.2.4 → 5.2.4-beta.2

package/dist/monitoring.esm.browser.js

@@ -1,1050 +0,0 @@
-function createAuth(appId, apiKey, authMode = 'WithinHeaders') {
-  const credentials = {
-    'x-algolia-api-key': apiKey,
-    'x-algolia-application-id': appId
-  };
-  return {
-    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
-  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(() => {
-        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)] = {
-          timestamp: new Date().getTime(),
-          value
-        };
-        getStorage().setItem(namespaceKey, JSON.stringify(namespace));
-        return value;
-      });
-    },
-    delete(key) {
-      return Promise.resolve().then(() => {
-        const namespace = getNamespace();
-        delete namespace[JSON.stringify(key)];
-        getStorage().setItem(namespaceKey, JSON.stringify(namespace));
-      });
-    },
-    clear() {
-      return Promise.resolve().then(() => {
-        getStorage().removeItem(namespaceKey);
-      });
-    }
-  };
-}
-
-function createNullCache() {
-  return {
-    get(_key, defaultValue, events = {
-      miss: () => Promise.resolve()
-    }) {
-      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()
-    }) {
-      return current.get(key, defaultValue, events).catch(() => {
-        return createFallbackableCache({
-          caches
-        }).get(key, defaultValue, events);
-      });
-    },
-    set(key, value) {
-      return current.set(key, value).catch(() => {
-        return createFallbackableCache({
-          caches
-        }).set(key, value);
-      });
-    },
-    delete(key) {
-      return current.delete(key).catch(() => {
-        return createFallbackableCache({
-          caches
-        }).delete(key);
-      });
-    },
-    clear() {
-      return current.clear().catch(() => {
-        return createFallbackableCache({
-          caches
-        }).clear();
-      });
-    }
-  };
-}
-
-function createMemoryCache(options = {
-  serializable: true
-}) {
-  let cache = {};
-  return {
-    get(key, defaultValue, events = {
-      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();
-    }
-  };
-}
-
-// By default, API Clients at Algolia have expiration delay of 5 mins.
-// In the JavaScript client, we have 2 mins.
-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,
-    status,
-    lastUpdate,
-    isUp,
-    isTimedOut
-  };
-}
-
-function _defineProperty(e, r, t) {
-  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-    value: t,
-    enumerable: !0,
-    configurable: !0,
-    writable: !0
-  }) : e[r] = t, e;
-}
-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 : i + "";
-}
-
-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
-    _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, please reach out to the Algolia Support team: https://alg.li/support.', stackTrace, 'RetryError');
-  }
-}
-class ApiError extends ErrorWithStackTrace {
-  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}${host.port ? `:${host.port}` : ''}/${path.charAt(0) === '/' ? path.substring(1) : path}`;
-  if (queryParametersAsString.length) {
-    url += `?${queryParametersAsString}`;
-  }
-  return url;
-}
-function serializeQueryParameters(parameters) {
-  return Object.keys(parameters).filter(key => parameters[key] !== undefined).sort().map(key => `${key}=${encodeURIComponent(Object.prototype.toString.call(parameters[key]) === '[object Array]' ? parameters[key].join(',') : 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,
-    ...requestOptions.data
-  };
-  return JSON.stringify(data);
-}
-function serializeHeaders(baseHeaders, requestHeaders, requestOptionsHeaders) {
-  const headers = {
-    Accept: 'application/json',
-    ...baseHeaders,
-    ...requestHeaders,
-    ...requestOptionsHeaders
-  };
-  const serializedHeaders = {};
-  Object.keys(headers).forEach(header => {
-    const value = headers[header];
-    serializedHeaders[header.toLowerCase()] = value;
-  });
-  return serializedHeaders;
-}
-function deserializeSuccess(response) {
-  try {
-    return JSON.parse(response.content);
-  } catch (e) {
-    throw new DeserializationError(e.message, response);
-  }
-}
-function deserializeFailure({
-  content,
-  status
-}, stackFrame) {
-  try {
-    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 {
-    // ..
-  }
-  return new ApiError(content, status, stackFrame);
-}
-
-function isNetworkError({
-  isTimedOut,
-  status
-}) {
-  return !isTimedOut && ~~status === 0;
-}
-function isRetryable({
-  isTimedOut,
-  status
-}) {
-  return isTimedOut || isNetworkError({
-    isTimedOut,
-    status
-  }) || ~~(status / 100) !== 2 && ~~(status / 100) !== 4;
-}
-function isSuccess({
-  status
-}) {
-  return ~~(status / 100) === 2;
-}
-
-function stackTraceWithoutCredentials(stackTrace) {
-  return stackTrace.map(stackFrame => stackFrameWithoutCredentials(stackFrame));
-}
-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,
-        ...modifiedHeaders
-      }
-    }
-  };
-}
-
-function createTransporter({
-  hosts,
-  hostsCache,
-  baseHeaders,
-  baseQueryParameters,
-  algoliaAgent,
-  timeouts,
-  requester,
-  requestsCache,
-  responsesCache
-}) {
-  async function createRetryableOptions(compatibleHosts) {
-    const statefulHosts = await Promise.all(compatibleHosts.map(compatibleHost => {
-      return hostsCache.get(compatibleHost, () => {
-        return Promise.resolve(createStatefulHost(compatibleHost));
-      });
-    }));
-    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 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.
-         */
-        const timeoutMultiplier = hostsTimedOut.length === 0 && timeoutsCount === 0 ? 1 : hostsTimedOut.length + 3 + timeoutsCount;
-        return timeoutMultiplier * baseTimeout;
-      }
-    };
-  }
-  async function retryableRequest(request, requestOptions, isRead = true) {
-    const stackTrace = [];
-    /**
-     * First we prepare the payload that do not depend from hosts.
-     */
-    const data = serializeData(request, requestOptions);
-    const headers = serializeHeaders(baseHeaders, request.headers, requestOptions.headers);
-    // On `GET`, the data is proxied to query parameters.
-    const dataQueryParameters = request.method === 'GET' ? {
-      ...request.data,
-      ...requestOptions.data
-    } : {};
-    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,
-        // but also avoid stringifying `object`s, as they are
-        // handled in the `serializeUrl` step right after.
-        if (!requestOptions.queryParameters[key] || Object.prototype.toString.call(requestOptions.queryParameters[key]) === '[object Object]') {
-          queryParameters[key] = requestOptions.queryParameters[key];
-        } else {
-          queryParameters[key] = requestOptions.queryParameters[key].toString();
-        }
-      }
-    }
-    let timeoutsCount = 0;
-    const retry = async (retryableHosts, getTimeout) => {
-      /**
-       * We iterate on each host, until there is no host left.
-       */
-      const host = retryableHosts.pop();
-      if (host === undefined) {
-        throw new RetryError(stackTraceWithoutCredentials(stackTrace));
-      }
-      const timeout = {
-        ...timeouts,
-        ...requestOptions.timeouts
-      };
-      const payload = {
-        data,
-        headers,
-        method: request.method,
-        url: serializeUrl(host, request.path, queryParameters),
-        connectTimeout: getTimeout(timeoutsCount, timeout.connect),
-        responseTimeout: getTimeout(timeoutsCount, isRead ? timeout.read : timeout.write)
-      };
-      /**
-       * The stackFrame is pushed to the stackTrace so we
-       * can have information about onRetry and onFailure
-       * decisions.
-       */
-      const pushToStackTrace = response => {
-        const stackFrame = {
-          request: payload,
-          response,
-          host,
-          triesLeft: retryableHosts.length
-        };
-        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.
-        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.
-         */
-        // eslint-disable-next-line no-console -- this will be fixed by exposing a `logger` to the transporter
-        console.log('Retryable failure', stackFrameWithoutCredentials(stackFrame));
-        /**
-         * We also store the state of the host in failure cases. If the host, is
-         * down it will remain down for the next 2 minutes. In a timeout situation,
-         * this host will be added end of the list of hosts on the next request.
-         */
-        await hostsCache.set(host, createStatefulHost(host, response.isTimedOut ? 'timed out' : 'down'));
-        return retry(retryableHosts, getTimeout);
-      }
-      if (isSuccess(response)) {
-        return deserializeSuccess(response);
-      }
-      pushToStackTrace(response);
-      throw deserializeFailure(response, stackTrace);
-    };
-    /**
-     * 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`).
-     */
-    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.
-       */
-      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.
-       */
-      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.
-     */
-    const cacheable = requestOptions.cacheable || request.cacheable;
-    /**
-     * If is not "cacheable", we immediately trigger the retryable request, no
-     * need to check cache implementations.
-     */
-    if (cacheable !== true) {
-      return createRetryableRequest();
-    }
-    /**
-     * 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,
-      transporter: {
-        queryParameters: baseQueryParameters,
-        headers: baseHeaders
-      }
-    };
-    /**
-     * 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.
-       */
-      return requestsCache.get(key, () =>
-      /**
-       * 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.
-       */
-      miss: response => responsesCache.set(key, response)
-    });
-  }
-  return {
-    hostsCache,
-    requester,
-    timeouts,
-    algoliaAgent,
-    baseHeaders,
-    baseQueryParameters,
-    hosts,
-    request: createRequest,
-    requestsCache,
-    responsesCache
-  };
-}
-
-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;
-}
-
-function getAlgoliaAgent({
-  algoliaAgents,
-  client,
-  version
-}) {
-  const defaultAlgoliaAgent = createAlgoliaAgent(version).add({
-    segment: client,
-    version
-  });
-  algoliaAgents.forEach(algoliaAgent => defaultAlgoliaAgent.add(algoliaAgent));
-  return defaultAlgoliaAgent;
-}
-
-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 };
-}
-
-// 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 = '1.2.4';
-function getDefaultHosts() {
-    return [{ url: 'status.algolia.com', accept: 'readWrite', protocol: 'https' }];
-}
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function createMonitoringClient({ appId: appIdOption, apiKey: apiKeyOption, authMode, algoliaAgents, ...options }) {
-    const auth = createAuth(appIdOption, apiKeyOption, authMode);
-    const transporter = createTransporter({
-        hosts: getDefaultHosts(),
-        ...options,
-        algoliaAgent: getAlgoliaAgent({
-            algoliaAgents,
-            client: 'Monitoring',
-            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.
-         *
-         * @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 = '/{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 = '/{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 = '/{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 = '/{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);
-        },
-        /**
-         * Retrieves known incidents for the selected clusters.
-         *
-         * @param getClusterIncidents - The getClusterIncidents object.
-         * @param getClusterIncidents.clusters - Subset of clusters, separated by comma.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getClusterIncidents({ clusters }, requestOptions) {
-            if (!clusters) {
-                throw new Error('Parameter `clusters` is required when calling `getClusterIncidents`.');
-            }
-            const requestPath = '/1/incidents/{clusters}'.replace('{clusters}', encodeURIComponent(clusters));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves the status of selected clusters.
-         *
-         * @param getClusterStatus - The getClusterStatus object.
-         * @param getClusterStatus.clusters - Subset of clusters, separated by comma.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getClusterStatus({ clusters }, requestOptions) {
-            if (!clusters) {
-                throw new Error('Parameter `clusters` is required when calling `getClusterStatus`.');
-            }
-            const requestPath = '/1/status/{clusters}'.replace('{clusters}', encodeURIComponent(clusters));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves known incidents for all clusters.
-         *
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getIncidents(requestOptions) {
-            const requestPath = '/1/incidents';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves average times for indexing operations for selected clusters.
-         *
-         * @param getIndexingTime - The getIndexingTime object.
-         * @param getIndexingTime.clusters - Subset of clusters, separated by comma.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getIndexingTime({ clusters }, requestOptions) {
-            if (!clusters) {
-                throw new Error('Parameter `clusters` is required when calling `getIndexingTime`.');
-            }
-            const requestPath = '/1/indexing/{clusters}'.replace('{clusters}', encodeURIComponent(clusters));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves the average latency for search requests for selected clusters.
-         *
-         * @param getLatency - The getLatency object.
-         * @param getLatency.clusters - Subset of clusters, separated by comma.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getLatency({ clusters }, requestOptions) {
-            if (!clusters) {
-                throw new Error('Parameter `clusters` is required when calling `getLatency`.');
-            }
-            const requestPath = '/1/latency/{clusters}'.replace('{clusters}', encodeURIComponent(clusters));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves metrics related to your Algolia infrastructure, aggregated over a selected time window.  Access to this API is available as part of the [Premium or Elevate plans](https://www.algolia.com/pricing). You must authenticate requests with the `x-algolia-application-id` and `x-algolia-api-key` headers (using the Monitoring API key).
-         *
-         * @param getMetrics - The getMetrics object.
-         * @param getMetrics.metric - Metric to report.  For more information about the individual metrics, see the description of the API response. To include all metrics, use `*`.
-         * @param getMetrics.period - Period over which to aggregate the metrics:  - `minute`. Aggregate the last minute. 1 data point per 10 seconds. - `hour`. Aggregate the last hour. 1 data point per minute. - `day`. Aggregate the last day. 1 data point per 10 minutes. - `week`. Aggregate the last week. 1 data point per hour. - `month`. Aggregate the last month. 1 data point per day.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getMetrics({ metric, period }, requestOptions) {
-            if (!metric) {
-                throw new Error('Parameter `metric` is required when calling `getMetrics`.');
-            }
-            if (!period) {
-                throw new Error('Parameter `period` is required when calling `getMetrics`.');
-            }
-            const requestPath = '/1/infrastructure/{metric}/period/{period}'
-                .replace('{metric}', encodeURIComponent(metric))
-                .replace('{period}', encodeURIComponent(period));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Test whether clusters are reachable or not.
-         *
-         * @param getReachability - The getReachability object.
-         * @param getReachability.clusters - Subset of clusters, separated by comma.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getReachability({ clusters }, requestOptions) {
-            if (!clusters) {
-                throw new Error('Parameter `clusters` is required when calling `getReachability`.');
-            }
-            const requestPath = '/1/reachability/{clusters}/probes'.replace('{clusters}', encodeURIComponent(clusters));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves the servers that belong to clusters.  The response depends on whether you authenticate your API request:  - With authentication, the response lists the servers assigned to your Algolia application\'s cluster.  - Without authentication, the response lists the servers for all Algolia clusters.
-         *
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getServers(requestOptions) {
-            const requestPath = '/1/inventory/servers';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves the status of all Algolia clusters and instances.
-         *
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getStatus(requestOptions) {
-            const requestPath = '/1/status';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            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.
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function monitoringClient(appId, apiKey, options) {
-    if (!appId || typeof appId !== 'string') {
-        throw new Error('`appId` is missing.');
-    }
-    if (!apiKey || typeof apiKey !== 'string') {
-        throw new Error('`apiKey` is missing.');
-    }
-    return createMonitoringClient({
-        appId,
-        apiKey,
-        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, monitoringClient };