@algolia/ingestion 1.2.4 → 5.2.4-beta.2

package/dist/ingestion.esm.browser.js

@@ -1,2678 +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';
-const REGIONS = ['eu', 'us'];
-function getDefaultHosts(region) {
-    const url = 'data.{region}.algolia.com'.replace('{region}', region);
-    return [{ url, accept: 'readWrite', protocol: 'https' }];
-}
-/**
- * Guard: Return strongly typed specific OnDemandTrigger for a given Trigger.
- *
- * @summary Guard method that returns a strongly typed specific OnDemandTrigger for a given Trigger.
- * @param trigger - The given Task Trigger.
- */
-function isOnDemandTrigger(trigger) {
-    return trigger.type === 'onDemand';
-}
-/**
- * Guard: Return strongly typed specific ScheduleTrigger for a given Trigger.
- *
- * @summary Guard method that returns a strongly typed specific ScheduleTrigger for a given Trigger.
- * @param trigger - The given Task Trigger.
- */
-function isScheduleTrigger(trigger) {
-    return trigger.type === 'schedule';
-}
-/**
- * Guard: Return strongly typed specific SubscriptionTrigger for a given Trigger.
- *
- * @summary Guard method that returns a strongly typed specific SubscriptionTrigger for a given Trigger.
- * @param trigger - The given Task Trigger.
- */
-function isSubscriptionTrigger(trigger) {
-    return trigger.type === 'subscription';
-}
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function createIngestionClient({ 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: 'Ingestion',
-            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 });
-        },
-        /**
-         * Creates a new authentication resource.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param authenticationCreate -.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createAuthentication(authenticationCreate, requestOptions) {
-            if (!authenticationCreate) {
-                throw new Error('Parameter `authenticationCreate` is required when calling `createAuthentication`.');
-            }
-            if (!authenticationCreate.type) {
-                throw new Error('Parameter `authenticationCreate.type` is required when calling `createAuthentication`.');
-            }
-            if (!authenticationCreate.name) {
-                throw new Error('Parameter `authenticationCreate.name` is required when calling `createAuthentication`.');
-            }
-            if (!authenticationCreate.input) {
-                throw new Error('Parameter `authenticationCreate.input` is required when calling `createAuthentication`.');
-            }
-            const requestPath = '/1/authentications';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: authenticationCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Creates a new destination.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param destinationCreate -.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createDestination(destinationCreate, requestOptions) {
-            if (!destinationCreate) {
-                throw new Error('Parameter `destinationCreate` is required when calling `createDestination`.');
-            }
-            if (!destinationCreate.type) {
-                throw new Error('Parameter `destinationCreate.type` is required when calling `createDestination`.');
-            }
-            if (!destinationCreate.name) {
-                throw new Error('Parameter `destinationCreate.name` is required when calling `createDestination`.');
-            }
-            if (!destinationCreate.input) {
-                throw new Error('Parameter `destinationCreate.input` is required when calling `createDestination`.');
-            }
-            const requestPath = '/1/destinations';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: destinationCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Creates a new source.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param sourceCreate -.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createSource(sourceCreate, requestOptions) {
-            if (!sourceCreate) {
-                throw new Error('Parameter `sourceCreate` is required when calling `createSource`.');
-            }
-            if (!sourceCreate.type) {
-                throw new Error('Parameter `sourceCreate.type` is required when calling `createSource`.');
-            }
-            if (!sourceCreate.name) {
-                throw new Error('Parameter `sourceCreate.name` is required when calling `createSource`.');
-            }
-            const requestPath = '/1/sources';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: sourceCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Creates a new task.
-         *
-         * @param taskCreate - Request body for creating a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createTask(taskCreate, requestOptions) {
-            if (!taskCreate) {
-                throw new Error('Parameter `taskCreate` is required when calling `createTask`.');
-            }
-            if (!taskCreate.sourceID) {
-                throw new Error('Parameter `taskCreate.sourceID` is required when calling `createTask`.');
-            }
-            if (!taskCreate.destinationID) {
-                throw new Error('Parameter `taskCreate.destinationID` is required when calling `createTask`.');
-            }
-            if (!taskCreate.action) {
-                throw new Error('Parameter `taskCreate.action` is required when calling `createTask`.');
-            }
-            const requestPath = '/2/tasks';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: taskCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Creates a new task using the v1 endpoint, please use `createTask` instead.
-         *
-         * @param taskCreate - Request body for creating a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createTaskV1(taskCreate, requestOptions) {
-            if (!taskCreate) {
-                throw new Error('Parameter `taskCreate` is required when calling `createTaskV1`.');
-            }
-            if (!taskCreate.sourceID) {
-                throw new Error('Parameter `taskCreate.sourceID` is required when calling `createTaskV1`.');
-            }
-            if (!taskCreate.destinationID) {
-                throw new Error('Parameter `taskCreate.destinationID` is required when calling `createTaskV1`.');
-            }
-            if (!taskCreate.trigger) {
-                throw new Error('Parameter `taskCreate.trigger` is required when calling `createTaskV1`.');
-            }
-            if (!taskCreate.action) {
-                throw new Error('Parameter `taskCreate.action` is required when calling `createTaskV1`.');
-            }
-            const requestPath = '/1/tasks';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: taskCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Creates a new transformation.
-         *
-         * @param transformationCreate - Request body for creating a transformation.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createTransformation(transformationCreate, requestOptions) {
-            if (!transformationCreate) {
-                throw new Error('Parameter `transformationCreate` is required when calling `createTransformation`.');
-            }
-            if (!transformationCreate.code) {
-                throw new Error('Parameter `transformationCreate.code` is required when calling `createTransformation`.');
-            }
-            if (!transformationCreate.name) {
-                throw new Error('Parameter `transformationCreate.name` is required when calling `createTransformation`.');
-            }
-            const requestPath = '/1/transformations';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: transformationCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * This method allow you to send requests to the Algolia REST API.
-         *
-         * @param customDelete - The customDelete object.
-         * @param customDelete.path - Path of the endpoint, anything after \"/1\" must be specified.
-         * @param customDelete.parameters - Query parameters to apply to the current query.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        customDelete({ path, parameters }, requestOptions) {
-            if (!path) {
-                throw new Error('Parameter `path` is required when calling `customDelete`.');
-            }
-            const requestPath = '/{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);
-        },
-        /**
-         * Deletes an authentication resource. You can\'t delete authentication resources that are used by a source or a destination.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param deleteAuthentication - The deleteAuthentication object.
-         * @param deleteAuthentication.authenticationID - Unique identifier of an authentication resource.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteAuthentication({ authenticationID }, requestOptions) {
-            if (!authenticationID) {
-                throw new Error('Parameter `authenticationID` is required when calling `deleteAuthentication`.');
-            }
-            const requestPath = '/1/authentications/{authenticationID}'.replace('{authenticationID}', encodeURIComponent(authenticationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Deletes a destination by its ID. You can\'t delete destinations that are referenced in tasks.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param deleteDestination - The deleteDestination object.
-         * @param deleteDestination.destinationID - Unique identifier of a destination.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteDestination({ destinationID }, requestOptions) {
-            if (!destinationID) {
-                throw new Error('Parameter `destinationID` is required when calling `deleteDestination`.');
-            }
-            const requestPath = '/1/destinations/{destinationID}'.replace('{destinationID}', encodeURIComponent(destinationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Deletes a source by its ID. You can\'t delete sources that are referenced in tasks.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param deleteSource - The deleteSource object.
-         * @param deleteSource.sourceID - Unique identifier of a source.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteSource({ sourceID }, requestOptions) {
-            if (!sourceID) {
-                throw new Error('Parameter `sourceID` is required when calling `deleteSource`.');
-            }
-            const requestPath = '/1/sources/{sourceID}'.replace('{sourceID}', encodeURIComponent(sourceID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Deletes a task by its ID.
-         *
-         * @param deleteTask - The deleteTask object.
-         * @param deleteTask.taskID - Unique identifier of a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteTask({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `deleteTask`.');
-            }
-            const requestPath = '/2/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Deletes a task by its ID using the v1 endpoint, please use `deleteTask` instead.
-         *
-         * @param deleteTaskV1 - The deleteTaskV1 object.
-         * @param deleteTaskV1.taskID - Unique identifier of a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteTaskV1({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `deleteTaskV1`.');
-            }
-            const requestPath = '/1/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Deletes a transformation by its ID.
-         *
-         * @param deleteTransformation - The deleteTransformation object.
-         * @param deleteTransformation.transformationID - Unique identifier of a transformation.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteTransformation({ transformationID }, requestOptions) {
-            if (!transformationID) {
-                throw new Error('Parameter `transformationID` is required when calling `deleteTransformation`.');
-            }
-            const requestPath = '/1/transformations/{transformationID}'.replace('{transformationID}', encodeURIComponent(transformationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Disables a task.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param disableTask - The disableTask object.
-         * @param disableTask.taskID - Unique identifier of a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        disableTask({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `disableTask`.');
-            }
-            const requestPath = '/2/tasks/{taskID}/disable'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PUT',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Disables a task using the v1 endpoint, please use `disableTask` instead.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param disableTaskV1 - The disableTaskV1 object.
-         * @param disableTaskV1.taskID - Unique identifier of a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        disableTaskV1({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `disableTaskV1`.');
-            }
-            const requestPath = '/1/tasks/{taskID}/disable'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PUT',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Enables a task.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param enableTask - The enableTask object.
-         * @param enableTask.taskID - Unique identifier of a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        enableTask({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `enableTask`.');
-            }
-            const requestPath = '/2/tasks/{taskID}/enable'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PUT',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Enables a task using the v1 endpoint, please use `enableTask` instead.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param enableTaskV1 - The enableTaskV1 object.
-         * @param enableTaskV1.taskID - Unique identifier of a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        enableTaskV1({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `enableTaskV1`.');
-            }
-            const requestPath = '/1/tasks/{taskID}/enable'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PUT',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Generates code for the selected model based on the given prompt.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param generateTransformationCodePayload - The generateTransformationCodePayload object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        generateTransformationCode(generateTransformationCodePayload, requestOptions) {
-            if (!generateTransformationCodePayload) {
-                throw new Error('Parameter `generateTransformationCodePayload` is required when calling `generateTransformationCode`.');
-            }
-            if (!generateTransformationCodePayload.id) {
-                throw new Error('Parameter `generateTransformationCodePayload.id` is required when calling `generateTransformationCode`.');
-            }
-            if (!generateTransformationCodePayload.userPrompt) {
-                throw new Error('Parameter `generateTransformationCodePayload.userPrompt` is required when calling `generateTransformationCode`.');
-            }
-            const requestPath = '/1/transformations/models';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: generateTransformationCodePayload,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves an authentication resource by its ID.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param getAuthentication - The getAuthentication object.
-         * @param getAuthentication.authenticationID - Unique identifier of an authentication resource.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getAuthentication({ authenticationID }, requestOptions) {
-            if (!authenticationID) {
-                throw new Error('Parameter `authenticationID` is required when calling `getAuthentication`.');
-            }
-            const requestPath = '/1/authentications/{authenticationID}'.replace('{authenticationID}', encodeURIComponent(authenticationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a destination by its ID.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param getDestination - The getDestination object.
-         * @param getDestination.destinationID - Unique identifier of a destination.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getDestination({ destinationID }, requestOptions) {
-            if (!destinationID) {
-                throw new Error('Parameter `destinationID` is required when calling `getDestination`.');
-            }
-            const requestPath = '/1/destinations/{destinationID}'.replace('{destinationID}', encodeURIComponent(destinationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a single task run event by its ID.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param getEvent - The getEvent object.
-         * @param getEvent.runID - Unique identifier of a task run.
-         * @param getEvent.eventID - Unique identifier of an event.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getEvent({ runID, eventID }, requestOptions) {
-            if (!runID) {
-                throw new Error('Parameter `runID` is required when calling `getEvent`.');
-            }
-            if (!eventID) {
-                throw new Error('Parameter `eventID` is required when calling `getEvent`.');
-            }
-            const requestPath = '/1/runs/{runID}/events/{eventID}'
-                .replace('{runID}', encodeURIComponent(runID))
-                .replace('{eventID}', encodeURIComponent(eventID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieve a single task run by its ID.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param getRun - The getRun object.
-         * @param getRun.runID - Unique identifier of a task run.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getRun({ runID }, requestOptions) {
-            if (!runID) {
-                throw new Error('Parameter `runID` is required when calling `getRun`.');
-            }
-            const requestPath = '/1/runs/{runID}'.replace('{runID}', encodeURIComponent(runID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieve a source by its ID.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param getSource - The getSource object.
-         * @param getSource.sourceID - Unique identifier of a source.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getSource({ sourceID }, requestOptions) {
-            if (!sourceID) {
-                throw new Error('Parameter `sourceID` is required when calling `getSource`.');
-            }
-            const requestPath = '/1/sources/{sourceID}'.replace('{sourceID}', encodeURIComponent(sourceID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a task by its ID.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param getTask - The getTask object.
-         * @param getTask.taskID - Unique identifier of a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getTask({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `getTask`.');
-            }
-            const requestPath = '/2/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a task by its ID using the v1 endpoint, please use `getTask` instead.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param getTaskV1 - The getTaskV1 object.
-         * @param getTaskV1.taskID - Unique identifier of a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getTaskV1({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `getTaskV1`.');
-            }
-            const requestPath = '/1/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a transformation by its ID.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param getTransformation - The getTransformation object.
-         * @param getTransformation.transformationID - Unique identifier of a transformation.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getTransformation({ transformationID }, requestOptions) {
-            if (!transformationID) {
-                throw new Error('Parameter `transformationID` is required when calling `getTransformation`.');
-            }
-            const requestPath = '/1/transformations/{transformationID}'.replace('{transformationID}', encodeURIComponent(transformationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a list of all authentication resources.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param listAuthentications - The listAuthentications object.
-         * @param listAuthentications.itemsPerPage - Number of items per page.
-         * @param listAuthentications.page - Page number of the paginated API response.
-         * @param listAuthentications.type - Type of authentication resource to retrieve.
-         * @param listAuthentications.platform - Ecommerce platform for which to retrieve authentication resources.
-         * @param listAuthentications.sort - Property by which to sort the list of authentication resources.
-         * @param listAuthentications.order - Sort order of the response, ascending or descending.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        listAuthentications({ itemsPerPage, page, type, platform, sort, order } = {}, requestOptions = undefined) {
-            const requestPath = '/1/authentications';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            if (type !== undefined) {
-                queryParameters.type = type.toString();
-            }
-            if (platform !== undefined) {
-                queryParameters.platform = platform.toString();
-            }
-            if (sort !== undefined) {
-                queryParameters.sort = sort.toString();
-            }
-            if (order !== undefined) {
-                queryParameters.order = order.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a list of destinations.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param listDestinations - The listDestinations object.
-         * @param listDestinations.itemsPerPage - Number of items per page.
-         * @param listDestinations.page - Page number of the paginated API response.
-         * @param listDestinations.type - Destination type.
-         * @param listDestinations.authenticationID - Authentication ID used by destinations.
-         * @param listDestinations.sort - Property by which to sort the destinations.
-         * @param listDestinations.order - Sort order of the response, ascending or descending.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        listDestinations({ itemsPerPage, page, type, authenticationID, sort, order } = {}, requestOptions = undefined) {
-            const requestPath = '/1/destinations';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            if (type !== undefined) {
-                queryParameters.type = type.toString();
-            }
-            if (authenticationID !== undefined) {
-                queryParameters.authenticationID = authenticationID.toString();
-            }
-            if (sort !== undefined) {
-                queryParameters.sort = sort.toString();
-            }
-            if (order !== undefined) {
-                queryParameters.order = order.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a list of events for a task run, identified by it\'s ID.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param listEvents - The listEvents object.
-         * @param listEvents.runID - Unique identifier of a task run.
-         * @param listEvents.itemsPerPage - Number of items per page.
-         * @param listEvents.page - Page number of the paginated API response.
-         * @param listEvents.status - Event status for filtering the list of task runs.
-         * @param listEvents.type - Event type for filtering the list of task runs.
-         * @param listEvents.sort - Property by which to sort the list of task run events.
-         * @param listEvents.order - Sort order of the response, ascending or descending.
-         * @param listEvents.startDate - Date and time in RFC 3339 format for the earliest events to retrieve. By default, the current time minus three hours is used.
-         * @param listEvents.endDate - Date and time in RFC 3339 format for the latest events to retrieve. By default, the current time is used.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        listEvents({ runID, itemsPerPage, page, status, type, sort, order, startDate, endDate }, requestOptions) {
-            if (!runID) {
-                throw new Error('Parameter `runID` is required when calling `listEvents`.');
-            }
-            const requestPath = '/1/runs/{runID}/events'.replace('{runID}', encodeURIComponent(runID));
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            if (status !== undefined) {
-                queryParameters.status = status.toString();
-            }
-            if (type !== undefined) {
-                queryParameters.type = type.toString();
-            }
-            if (sort !== undefined) {
-                queryParameters.sort = sort.toString();
-            }
-            if (order !== undefined) {
-                queryParameters.order = order.toString();
-            }
-            if (startDate !== undefined) {
-                queryParameters.startDate = startDate.toString();
-            }
-            if (endDate !== undefined) {
-                queryParameters.endDate = endDate.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieve a list of task runs.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param listRuns - The listRuns object.
-         * @param listRuns.itemsPerPage - Number of items per page.
-         * @param listRuns.page - Page number of the paginated API response.
-         * @param listRuns.status - Run status for filtering the list of task runs.
-         * @param listRuns.type - Run type for filtering the list of task runs.
-         * @param listRuns.taskID - Task ID for filtering the list of task runs.
-         * @param listRuns.sort - Property by which to sort the list of task runs.
-         * @param listRuns.order - Sort order of the response, ascending or descending.
-         * @param listRuns.startDate - Date in RFC 3339 format for the earliest run to retrieve. By default, the current day minus seven days is used.
-         * @param listRuns.endDate - Date in RFC 3339 format for the latest run to retrieve. By default, the current day is used.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        listRuns({ itemsPerPage, page, status, type, taskID, sort, order, startDate, endDate } = {}, requestOptions = undefined) {
-            const requestPath = '/1/runs';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            if (status !== undefined) {
-                queryParameters.status = status.toString();
-            }
-            if (type !== undefined) {
-                queryParameters.type = type.toString();
-            }
-            if (taskID !== undefined) {
-                queryParameters.taskID = taskID.toString();
-            }
-            if (sort !== undefined) {
-                queryParameters.sort = sort.toString();
-            }
-            if (order !== undefined) {
-                queryParameters.order = order.toString();
-            }
-            if (startDate !== undefined) {
-                queryParameters.startDate = startDate.toString();
-            }
-            if (endDate !== undefined) {
-                queryParameters.endDate = endDate.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a list of sources.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param listSources - The listSources object.
-         * @param listSources.itemsPerPage - Number of items per page.
-         * @param listSources.page - Page number of the paginated API response.
-         * @param listSources.type - Source type. Some sources require authentication.
-         * @param listSources.authenticationID - Authentication IDs of the sources to retrieve. \'none\' returns sources that doesn\'t have an authentication resource.
-         * @param listSources.sort - Property by which to sort the list of sources.
-         * @param listSources.order - Sort order of the response, ascending or descending.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        listSources({ itemsPerPage, page, type, authenticationID, sort, order } = {}, requestOptions = undefined) {
-            const requestPath = '/1/sources';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            if (type !== undefined) {
-                queryParameters.type = type.toString();
-            }
-            if (authenticationID !== undefined) {
-                queryParameters.authenticationID = authenticationID.toString();
-            }
-            if (sort !== undefined) {
-                queryParameters.sort = sort.toString();
-            }
-            if (order !== undefined) {
-                queryParameters.order = order.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a list of tasks.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param listTasks - The listTasks object.
-         * @param listTasks.itemsPerPage - Number of items per page.
-         * @param listTasks.page - Page number of the paginated API response.
-         * @param listTasks.action - Actions for filtering the list of tasks.
-         * @param listTasks.enabled - Whether to filter the list of tasks by the `enabled` status.
-         * @param listTasks.sourceID - Source IDs for filtering the list of tasks.
-         * @param listTasks.destinationID - Destination IDs for filtering the list of tasks.
-         * @param listTasks.triggerType - Type of task trigger for filtering the list of tasks.
-         * @param listTasks.sort - Property by which to sort the list of tasks.
-         * @param listTasks.order - Sort order of the response, ascending or descending.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        listTasks({ itemsPerPage, page, action, enabled, sourceID, destinationID, triggerType, sort, order } = {}, requestOptions = undefined) {
-            const requestPath = '/2/tasks';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            if (action !== undefined) {
-                queryParameters.action = action.toString();
-            }
-            if (enabled !== undefined) {
-                queryParameters.enabled = enabled.toString();
-            }
-            if (sourceID !== undefined) {
-                queryParameters.sourceID = sourceID.toString();
-            }
-            if (destinationID !== undefined) {
-                queryParameters.destinationID = destinationID.toString();
-            }
-            if (triggerType !== undefined) {
-                queryParameters.triggerType = triggerType.toString();
-            }
-            if (sort !== undefined) {
-                queryParameters.sort = sort.toString();
-            }
-            if (order !== undefined) {
-                queryParameters.order = order.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a list of tasks using the v1 endpoint, please use `getTasks` instead.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param listTasksV1 - The listTasksV1 object.
-         * @param listTasksV1.itemsPerPage - Number of items per page.
-         * @param listTasksV1.page - Page number of the paginated API response.
-         * @param listTasksV1.action - Actions for filtering the list of tasks.
-         * @param listTasksV1.enabled - Whether to filter the list of tasks by the `enabled` status.
-         * @param listTasksV1.sourceID - Source IDs for filtering the list of tasks.
-         * @param listTasksV1.destinationID - Destination IDs for filtering the list of tasks.
-         * @param listTasksV1.triggerType - Type of task trigger for filtering the list of tasks.
-         * @param listTasksV1.sort - Property by which to sort the list of tasks.
-         * @param listTasksV1.order - Sort order of the response, ascending or descending.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        listTasksV1({ itemsPerPage, page, action, enabled, sourceID, destinationID, triggerType, sort, order } = {}, requestOptions = undefined) {
-            const requestPath = '/1/tasks';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            if (action !== undefined) {
-                queryParameters.action = action.toString();
-            }
-            if (enabled !== undefined) {
-                queryParameters.enabled = enabled.toString();
-            }
-            if (sourceID !== undefined) {
-                queryParameters.sourceID = sourceID.toString();
-            }
-            if (destinationID !== undefined) {
-                queryParameters.destinationID = destinationID.toString();
-            }
-            if (triggerType !== undefined) {
-                queryParameters.triggerType = triggerType.toString();
-            }
-            if (sort !== undefined) {
-                queryParameters.sort = sort.toString();
-            }
-            if (order !== undefined) {
-                queryParameters.order = order.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a list of existing LLM transformation helpers.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        listTransformationModels(requestOptions) {
-            const requestPath = '/1/transformations/models';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Retrieves a list of transformations.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param listTransformations - The listTransformations object.
-         * @param listTransformations.itemsPerPage - Number of items per page.
-         * @param listTransformations.page - Page number of the paginated API response.
-         * @param listTransformations.sort - Property by which to sort the list.
-         * @param listTransformations.order - Sort order of the response, ascending or descending.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        listTransformations({ itemsPerPage, page, sort, order } = {}, requestOptions = undefined) {
-            const requestPath = '/1/transformations';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            if (sort !== undefined) {
-                queryParameters.sort = sort.toString();
-            }
-            if (order !== undefined) {
-                queryParameters.order = order.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Push a `batch` request payload through the Pipeline. You can check the status of task pushes with the observability endpoints.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param pushTask - The pushTask object.
-         * @param pushTask.taskID - Unique identifier of a task.
-         * @param pushTask.pushTaskPayload - Request body of a Search API `batch` request that will be pushed in the Connectors pipeline.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        pushTask({ taskID, pushTaskPayload }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `pushTask`.');
-            }
-            if (!pushTaskPayload) {
-                throw new Error('Parameter `pushTaskPayload` is required when calling `pushTask`.');
-            }
-            if (!pushTaskPayload.action) {
-                throw new Error('Parameter `pushTaskPayload.action` is required when calling `pushTask`.');
-            }
-            if (!pushTaskPayload.records) {
-                throw new Error('Parameter `pushTaskPayload.records` is required when calling `pushTask`.');
-            }
-            const requestPath = '/2/tasks/{taskID}/push'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: pushTaskPayload,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Runs all tasks linked to a source, only available for Shopify sources. It will create 1 run per task.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param runSource - The runSource object.
-         * @param runSource.sourceID - Unique identifier of a source.
-         * @param runSource.runSourcePayload -.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        runSource({ sourceID, runSourcePayload }, requestOptions) {
-            if (!sourceID) {
-                throw new Error('Parameter `sourceID` is required when calling `runSource`.');
-            }
-            const requestPath = '/1/sources/{sourceID}/run'.replace('{sourceID}', encodeURIComponent(sourceID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: runSourcePayload ? runSourcePayload : {},
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Runs a task. You can check the status of task runs with the observability endpoints.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param runTask - The runTask object.
-         * @param runTask.taskID - Unique identifier of a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        runTask({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `runTask`.');
-            }
-            const requestPath = '/2/tasks/{taskID}/run'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Runs a task using the v1 endpoint, please use `runTask` instead. You can check the status of task runs with the observability endpoints.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param runTaskV1 - The runTaskV1 object.
-         * @param runTaskV1.taskID - Unique identifier of a task.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        runTaskV1({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `runTaskV1`.');
-            }
-            const requestPath = '/1/tasks/{taskID}/run'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Searches for authentication resources.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param authenticationSearch - The authenticationSearch object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        searchAuthentications(authenticationSearch, requestOptions) {
-            if (!authenticationSearch) {
-                throw new Error('Parameter `authenticationSearch` is required when calling `searchAuthentications`.');
-            }
-            if (!authenticationSearch.authenticationIDs) {
-                throw new Error('Parameter `authenticationSearch.authenticationIDs` is required when calling `searchAuthentications`.');
-            }
-            const requestPath = '/1/authentications/search';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: authenticationSearch,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Searches for destinations.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param destinationSearch - The destinationSearch object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        searchDestinations(destinationSearch, requestOptions) {
-            if (!destinationSearch) {
-                throw new Error('Parameter `destinationSearch` is required when calling `searchDestinations`.');
-            }
-            if (!destinationSearch.destinationIDs) {
-                throw new Error('Parameter `destinationSearch.destinationIDs` is required when calling `searchDestinations`.');
-            }
-            const requestPath = '/1/destinations/search';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: destinationSearch,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Searches for sources.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param sourceSearch - The sourceSearch object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        searchSources(sourceSearch, requestOptions) {
-            if (!sourceSearch) {
-                throw new Error('Parameter `sourceSearch` is required when calling `searchSources`.');
-            }
-            if (!sourceSearch.sourceIDs) {
-                throw new Error('Parameter `sourceSearch.sourceIDs` is required when calling `searchSources`.');
-            }
-            const requestPath = '/1/sources/search';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: sourceSearch,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Searches for tasks.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param taskSearch - The taskSearch object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        searchTasks(taskSearch, requestOptions) {
-            if (!taskSearch) {
-                throw new Error('Parameter `taskSearch` is required when calling `searchTasks`.');
-            }
-            if (!taskSearch.taskIDs) {
-                throw new Error('Parameter `taskSearch.taskIDs` is required when calling `searchTasks`.');
-            }
-            const requestPath = '/2/tasks/search';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: taskSearch,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Searches for tasks using the v1 endpoint, please use `searchTasks` instead.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param taskSearch - The taskSearch object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        searchTasksV1(taskSearch, requestOptions) {
-            if (!taskSearch) {
-                throw new Error('Parameter `taskSearch` is required when calling `searchTasksV1`.');
-            }
-            if (!taskSearch.taskIDs) {
-                throw new Error('Parameter `taskSearch.taskIDs` is required when calling `searchTasksV1`.');
-            }
-            const requestPath = '/1/tasks/search';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: taskSearch,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Searches for transformations.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param transformationSearch - The transformationSearch object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        searchTransformations(transformationSearch, requestOptions) {
-            if (!transformationSearch) {
-                throw new Error('Parameter `transformationSearch` is required when calling `searchTransformations`.');
-            }
-            if (!transformationSearch.transformationIDs) {
-                throw new Error('Parameter `transformationSearch.transformationIDs` is required when calling `searchTransformations`.');
-            }
-            const requestPath = '/1/transformations/search';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: transformationSearch,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Triggers a stream-listing request for a source. Triggering stream-listing requests only works with sources with `type: docker` and `imageType: singer`.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param triggerDockerSourceDiscover - The triggerDockerSourceDiscover object.
-         * @param triggerDockerSourceDiscover.sourceID - Unique identifier of a source.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        triggerDockerSourceDiscover({ sourceID }, requestOptions) {
-            if (!sourceID) {
-                throw new Error('Parameter `sourceID` is required when calling `triggerDockerSourceDiscover`.');
-            }
-            const requestPath = '/1/sources/{sourceID}/discover'.replace('{sourceID}', encodeURIComponent(sourceID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Try a transformation before creating it.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param transformationTry - The transformationTry object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        tryTransformation(transformationTry, requestOptions) {
-            if (!transformationTry) {
-                throw new Error('Parameter `transformationTry` is required when calling `tryTransformation`.');
-            }
-            if (!transformationTry.code) {
-                throw new Error('Parameter `transformationTry.code` is required when calling `tryTransformation`.');
-            }
-            if (!transformationTry.sampleRecord) {
-                throw new Error('Parameter `transformationTry.sampleRecord` is required when calling `tryTransformation`.');
-            }
-            const requestPath = '/1/transformations/try';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: transformationTry,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Try a transformation before updating it.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param tryTransformationBeforeUpdate - The tryTransformationBeforeUpdate object.
-         * @param tryTransformationBeforeUpdate.transformationID - Unique identifier of a transformation.
-         * @param tryTransformationBeforeUpdate.transformationTry - The transformationTry object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        tryTransformationBeforeUpdate({ transformationID, transformationTry }, requestOptions) {
-            if (!transformationID) {
-                throw new Error('Parameter `transformationID` is required when calling `tryTransformationBeforeUpdate`.');
-            }
-            if (!transformationTry) {
-                throw new Error('Parameter `transformationTry` is required when calling `tryTransformationBeforeUpdate`.');
-            }
-            if (!transformationTry.code) {
-                throw new Error('Parameter `transformationTry.code` is required when calling `tryTransformationBeforeUpdate`.');
-            }
-            if (!transformationTry.sampleRecord) {
-                throw new Error('Parameter `transformationTry.sampleRecord` is required when calling `tryTransformationBeforeUpdate`.');
-            }
-            const requestPath = '/1/transformations/{transformationID}/try'.replace('{transformationID}', encodeURIComponent(transformationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: transformationTry,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Updates an authentication resource.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param updateAuthentication - The updateAuthentication object.
-         * @param updateAuthentication.authenticationID - Unique identifier of an authentication resource.
-         * @param updateAuthentication.authenticationUpdate - The authenticationUpdate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateAuthentication({ authenticationID, authenticationUpdate }, requestOptions) {
-            if (!authenticationID) {
-                throw new Error('Parameter `authenticationID` is required when calling `updateAuthentication`.');
-            }
-            if (!authenticationUpdate) {
-                throw new Error('Parameter `authenticationUpdate` is required when calling `updateAuthentication`.');
-            }
-            const requestPath = '/1/authentications/{authenticationID}'.replace('{authenticationID}', encodeURIComponent(authenticationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PATCH',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: authenticationUpdate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Updates the destination by its ID.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param updateDestination - The updateDestination object.
-         * @param updateDestination.destinationID - Unique identifier of a destination.
-         * @param updateDestination.destinationUpdate - The destinationUpdate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateDestination({ destinationID, destinationUpdate }, requestOptions) {
-            if (!destinationID) {
-                throw new Error('Parameter `destinationID` is required when calling `updateDestination`.');
-            }
-            if (!destinationUpdate) {
-                throw new Error('Parameter `destinationUpdate` is required when calling `updateDestination`.');
-            }
-            const requestPath = '/1/destinations/{destinationID}'.replace('{destinationID}', encodeURIComponent(destinationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PATCH',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: destinationUpdate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Updates a source by its ID.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param updateSource - The updateSource object.
-         * @param updateSource.sourceID - Unique identifier of a source.
-         * @param updateSource.sourceUpdate - The sourceUpdate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateSource({ sourceID, sourceUpdate }, requestOptions) {
-            if (!sourceID) {
-                throw new Error('Parameter `sourceID` is required when calling `updateSource`.');
-            }
-            if (!sourceUpdate) {
-                throw new Error('Parameter `sourceUpdate` is required when calling `updateSource`.');
-            }
-            const requestPath = '/1/sources/{sourceID}'.replace('{sourceID}', encodeURIComponent(sourceID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PATCH',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: sourceUpdate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Updates a task by its ID.
-         *
-         * @param updateTask - The updateTask object.
-         * @param updateTask.taskID - Unique identifier of a task.
-         * @param updateTask.taskUpdate - The taskUpdate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateTask({ taskID, taskUpdate }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `updateTask`.');
-            }
-            if (!taskUpdate) {
-                throw new Error('Parameter `taskUpdate` is required when calling `updateTask`.');
-            }
-            const requestPath = '/2/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PATCH',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: taskUpdate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Updates a task by its ID using the v1 endpoint, please use `updateTask` instead.
-         *
-         * @param updateTaskV1 - The updateTaskV1 object.
-         * @param updateTaskV1.taskID - Unique identifier of a task.
-         * @param updateTaskV1.taskUpdate - The taskUpdate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateTaskV1({ taskID, taskUpdate }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `updateTaskV1`.');
-            }
-            if (!taskUpdate) {
-                throw new Error('Parameter `taskUpdate` is required when calling `updateTaskV1`.');
-            }
-            const requestPath = '/1/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PATCH',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: taskUpdate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Updates a transformation by its ID.
-         *
-         * @param updateTransformation - The updateTransformation object.
-         * @param updateTransformation.transformationID - Unique identifier of a transformation.
-         * @param updateTransformation.transformationCreate - The transformationCreate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateTransformation({ transformationID, transformationCreate }, requestOptions) {
-            if (!transformationID) {
-                throw new Error('Parameter `transformationID` is required when calling `updateTransformation`.');
-            }
-            if (!transformationCreate) {
-                throw new Error('Parameter `transformationCreate` is required when calling `updateTransformation`.');
-            }
-            if (!transformationCreate.code) {
-                throw new Error('Parameter `transformationCreate.code` is required when calling `updateTransformation`.');
-            }
-            if (!transformationCreate.name) {
-                throw new Error('Parameter `transformationCreate.name` is required when calling `updateTransformation`.');
-            }
-            const requestPath = '/1/transformations/{transformationID}'.replace('{transformationID}', encodeURIComponent(transformationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PUT',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: transformationCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Validates a source payload to ensure it can be created and that the data source can be reached by Algolia.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param sourceCreate -.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        validateSource(sourceCreate, requestOptions = undefined) {
-            const requestPath = '/1/sources/validate';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: sourceCreate ? sourceCreate : {},
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Validates an update of a source payload to ensure it can be created and that the data source can be reached by Algolia.
-         *
-         * Required API Key ACLs:
-         * - addObject
-         * - deleteIndex
-         * - editSettings.
-         *
-         * @param validateSourceBeforeUpdate - The validateSourceBeforeUpdate object.
-         * @param validateSourceBeforeUpdate.sourceID - Unique identifier of a source.
-         * @param validateSourceBeforeUpdate.sourceUpdate - The sourceUpdate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        validateSourceBeforeUpdate({ sourceID, sourceUpdate }, requestOptions) {
-            if (!sourceID) {
-                throw new Error('Parameter `sourceID` is required when calling `validateSourceBeforeUpdate`.');
-            }
-            if (!sourceUpdate) {
-                throw new Error('Parameter `sourceUpdate` is required when calling `validateSourceBeforeUpdate`.');
-            }
-            const requestPath = '/1/sources/{sourceID}/validate'.replace('{sourceID}', encodeURIComponent(sourceID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: sourceUpdate,
-            };
-            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 ingestionClient(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 createIngestionClient({
-        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, ingestionClient, isOnDemandTrigger, isScheduleTrigger, isSubscriptionTrigger };