@algolia/client-common 5.2.3 → 5.2.4-beta.2

package/dist/client-common.esm.node.js

@@ -1,747 +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 getUrlParams({
-  host,
-  search,
-  pathname
-}) {
-  const urlSearchParams = search.split('?');
-  if (urlSearchParams.length === 1) {
-    return {
-      host,
-      algoliaAgent: '',
-      searchParams: undefined,
-      path: pathname
-    };
-  }
-  const splitSearchParams = urlSearchParams[1].split('&');
-  let algoliaAgent = '';
-  const searchParams = {};
-  if (splitSearchParams.length > 0) {
-    splitSearchParams.forEach(param => {
-      const [key, value] = param.split('=');
-      if (key === 'x-algolia-agent') {
-        algoliaAgent = value;
-        return;
-      }
-      searchParams[key] = value;
-    });
-  }
-  return {
-    host,
-    algoliaAgent,
-    searchParams: Object.keys(searchParams).length === 0 ? undefined : searchParams,
-    path: pathname
-  };
-}
-function createEchoRequester({
-  getURL,
-  status = 200
-}) {
-  function send(request) {
-    const {
-      host,
-      searchParams,
-      algoliaAgent,
-      path
-    } = getUrlParams(getURL(request.url));
-    const content = {
-      ...request,
-      data: request.data ? JSON.parse(request.data) : undefined,
-      path,
-      host,
-      algoliaAgent,
-      searchParams
-    };
-    return Promise.resolve({
-      content: JSON.stringify(content),
-      isTimedOut: false,
-      status
-    });
-  }
-  return {
-    send
-  };
-}
-
-/**
- * Helper: Returns the promise of a given `func` to iterate on, based on a given `validate` condition.
- *
- * @param createIterator - The createIterator options.
- * @param createIterator.func - The function to run, which returns a promise.
- * @param createIterator.validate - The validator function. It receives the resolved return of `func`.
- * @param createIterator.aggregator - The function that runs right after the `func` method has been executed, allows you to do anything with the response before `validate`.
- * @param createIterator.error - The `validate` condition to throw an error, and its message.
- * @param createIterator.timeout - The function to decide how long to wait between iterations.
- */
-function createIterablePromise({
-  func,
-  validate,
-  aggregator,
-  error,
-  timeout = () => 0
-}) {
-  const retry = previousResponse => {
-    return new Promise((resolve, reject) => {
-      func(previousResponse).then(response => {
-        if (aggregator) {
-          aggregator(response);
-        }
-        if (validate(response)) {
-          return resolve(response);
-        }
-        if (error && error.validate(response)) {
-          return reject(new Error(error.message(response)));
-        }
-        return setTimeout(() => {
-          retry(response).then(resolve).catch(reject);
-        }, timeout());
-      }).catch(err => {
-        reject(err);
-      });
-    });
-  };
-  return retry();
-}
-
-function createBrowserLocalStorageCache(options) {
-  let storage;
-  // We've changed the namespace to avoid conflicts with v4, as this version is a huge breaking change
-  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 shuffle(array) {
-  const shuffledArray = array;
-  for (let c = array.length - 1; c > 0; c--) {
-    const b = Math.floor(Math.random() * (c + 1));
-    const a = array[c];
-    shuffledArray[c] = array[b];
-    shuffledArray[b] = a;
-  }
-  return shuffledArray;
-}
-function serializeUrl(host, path, queryParameters) {
-  const queryParametersAsString = serializeQueryParameters(queryParameters);
-  let url = `${host.protocol}://${host.url}${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;
-const DEFAULT_CONNECT_TIMEOUT_NODE = 2000;
-const DEFAULT_READ_TIMEOUT_NODE = 5000;
-const DEFAULT_WRITE_TIMEOUT_NODE = 30000;
-
-export { AlgoliaError, ApiError, DEFAULT_CONNECT_TIMEOUT_BROWSER, DEFAULT_CONNECT_TIMEOUT_NODE, DEFAULT_READ_TIMEOUT_BROWSER, DEFAULT_READ_TIMEOUT_NODE, DEFAULT_WRITE_TIMEOUT_BROWSER, DEFAULT_WRITE_TIMEOUT_NODE, DeserializationError, DetailedApiError, ErrorWithStackTrace, RetryError, createAlgoliaAgent, createAuth, createBrowserLocalStorageCache, createEchoRequester, createFallbackableCache, createIterablePromise, createMemoryCache, createNullCache, createStatefulHost, createTransporter, deserializeFailure, deserializeSuccess, getAlgoliaAgent, isNetworkError, isRetryable, isSuccess, serializeData, serializeHeaders, serializeQueryParameters, serializeUrl, shuffle, stackFrameWithoutCredentials, stackTraceWithoutCredentials };