@algolia/ingestion 1.55.1 → 1.56.0

package/dist/builds/node.js

@@ -11,7 +11,7 @@ import {
   getAlgoliaAgent,
   validateRequired
 } from "@algolia/client-common";
-var apiClientVersion = "1.55.1";
+var apiClientVersion = "1.56.0";
 var REGIONS = ["eu", "us"];
 function getDefaultHosts(region) {
   const url = "data.{region}.algolia.com".replace("{region}", region);
@@ -120,10 +120,41 @@ function createIngestionClient({
       referenceIndexName,
       maxRetries = 100
     }, requestOptions) {
+      if (batchSize < 1) {
+        throw new Error("`batchSize` must be at least 1.");
+      }
       let records = [];
       let offset = 0;
       const responses = [];
       const waitBatchSize = Math.floor(batchSize / 10) || batchSize;
+      const waitForBatch = async (start, end) => {
+        for (const resp of responses.slice(start, end)) {
+          if (!resp.eventID) {
+            throw new Error("received unexpected response from the push endpoint, eventID must not be undefined");
+          }
+          let retryCount = 0;
+          await createIterablePromise({
+            func: async () => {
+              if (resp.eventID === void 0 || !resp.eventID) {
+                throw new Error("received unexpected response from the push endpoint, eventID must not be undefined");
+              }
+              return this.getEvent({ runID: resp.runID, eventID: resp.eventID }).catch((error) => {
+                if (error.status === 404) {
+                  return void 0;
+                }
+                throw error;
+              });
+            },
+            validate: (response) => response !== void 0,
+            aggregator: () => retryCount += 1,
+            error: {
+              validate: () => retryCount >= maxRetries,
+              message: () => `Stopped waiting for the task after ${maxRetries} retries. This does not mean the operation failed; it may still complete. If you need to keep polling, retry with a higher maxRetries.`
+            },
+            timeout: () => Math.min(retryCount * 1500, 5e3)
+          });
+        }
+      };
       const objectEntries = objects.entries();
       for (const [i, obj] of objectEntries) {
         records.push(obj);
@@ -133,36 +164,14 @@ function createIngestionClient({
           );
           records = [];
         }
-        if (waitForTasks && responses.length > 0 && (responses.length % waitBatchSize === 0 || i === objects.length - 1)) {
-          for (const resp of responses.slice(offset, offset + waitBatchSize)) {
-            if (!resp.eventID) {
-              throw new Error("received unexpected response from the push endpoint, eventID must not be undefined");
-            }
-            let retryCount = 0;
-            await createIterablePromise({
-              func: async () => {
-                if (resp.eventID === void 0 || !resp.eventID) {
-                  throw new Error("received unexpected response from the push endpoint, eventID must not be undefined");
-                }
-                return this.getEvent({ runID: resp.runID, eventID: resp.eventID }).catch((error) => {
-                  if (error.status === 404) {
-                    return void 0;
-                  }
-                  throw error;
-                });
-              },
-              validate: (response) => response !== void 0,
-              aggregator: () => retryCount += 1,
-              error: {
-                validate: () => retryCount >= maxRetries,
-                message: () => `Stopped waiting for the task after ${maxRetries} retries. This does not mean the operation failed; it may still complete. If you need to keep polling, retry with a higher maxRetries.`
-              },
-              timeout: () => Math.min(retryCount * 1500, 5e3)
-            });
-          }
+        if (waitForTasks && responses.length - offset >= waitBatchSize) {
+          await waitForBatch(offset, offset + waitBatchSize);
           offset += waitBatchSize;
         }
       }
+      if (waitForTasks) {
+        await waitForBatch(offset, responses.length);
+      }
       return responses;
     },
     /**
@@ -192,6 +201,36 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Creates a new authentication resource.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see createAuthentication for the plain version.
+     */
+    createAuthenticationWithHTTPInfo(authenticationCreate, requestOptions) {
+      validateRequired("authenticationCreate", "createAuthenticationWithHTTPInfo", authenticationCreate);
+      validateRequired("authenticationCreate.type", "createAuthenticationWithHTTPInfo", authenticationCreate.type);
+      validateRequired("authenticationCreate.name", "createAuthenticationWithHTTPInfo", authenticationCreate.name);
+      validateRequired("authenticationCreate.input", "createAuthenticationWithHTTPInfo", authenticationCreate.input);
+      const requestPath = "/1/authentications";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: authenticationCreate
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Creates a new destination.
      *
@@ -219,6 +258,36 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Creates a new destination.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see createDestination for the plain version.
+     */
+    createDestinationWithHTTPInfo(destinationCreate, requestOptions) {
+      validateRequired("destinationCreate", "createDestinationWithHTTPInfo", destinationCreate);
+      validateRequired("destinationCreate.type", "createDestinationWithHTTPInfo", destinationCreate.type);
+      validateRequired("destinationCreate.name", "createDestinationWithHTTPInfo", destinationCreate.name);
+      validateRequired("destinationCreate.input", "createDestinationWithHTTPInfo", destinationCreate.input);
+      const requestPath = "/1/destinations";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: destinationCreate
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Creates a new source.
      *
@@ -245,6 +314,35 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Creates a new source.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see createSource for the plain version.
+     */
+    createSourceWithHTTPInfo(sourceCreate, requestOptions) {
+      validateRequired("sourceCreate", "createSourceWithHTTPInfo", sourceCreate);
+      validateRequired("sourceCreate.type", "createSourceWithHTTPInfo", sourceCreate.type);
+      validateRequired("sourceCreate.name", "createSourceWithHTTPInfo", sourceCreate.name);
+      const requestPath = "/1/sources";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: sourceCreate
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Creates a new task.
      *
@@ -272,6 +370,36 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Creates a new task.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     * @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.
+     * @see createTask for the plain version.
+     */
+    createTaskWithHTTPInfo(taskCreate, requestOptions) {
+      validateRequired("taskCreate", "createTaskWithHTTPInfo", taskCreate);
+      validateRequired("taskCreate.sourceID", "createTaskWithHTTPInfo", taskCreate.sourceID);
+      validateRequired("taskCreate.destinationID", "createTaskWithHTTPInfo", taskCreate.destinationID);
+      validateRequired("taskCreate.action", "createTaskWithHTTPInfo", taskCreate.action);
+      const requestPath = "/2/tasks";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: taskCreate
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Creates a new task using the v1 endpoint. Use `createTask` instead.
      *
@@ -302,6 +430,39 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Creates a new task using the v1 endpoint. Use `createTask` instead.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     *
+     * @deprecated
+     * @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.
+     * @see createTaskV1 for the plain version.
+     */
+    createTaskV1WithHTTPInfo(taskCreate, requestOptions) {
+      validateRequired("taskCreate", "createTaskV1WithHTTPInfo", taskCreate);
+      validateRequired("taskCreate.sourceID", "createTaskV1WithHTTPInfo", taskCreate.sourceID);
+      validateRequired("taskCreate.destinationID", "createTaskV1WithHTTPInfo", taskCreate.destinationID);
+      validateRequired("taskCreate.trigger", "createTaskV1WithHTTPInfo", taskCreate.trigger);
+      validateRequired("taskCreate.action", "createTaskV1WithHTTPInfo", taskCreate.action);
+      const requestPath = "/1/tasks";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: taskCreate
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Creates a new transformation.
      *
@@ -327,6 +488,34 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Creates a new transformation.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     * @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.
+     * @see createTransformation for the plain version.
+     */
+    createTransformationWithHTTPInfo(transformationCreate, requestOptions) {
+      validateRequired("transformationCreate", "createTransformationWithHTTPInfo", transformationCreate);
+      validateRequired("transformationCreate.name", "createTransformationWithHTTPInfo", transformationCreate.name);
+      const requestPath = "/1/transformations";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: transformationCreate
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * This method lets you send requests to the Algolia REST API.
      * @param customDelete - The customDelete object.
@@ -347,6 +536,29 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     * @param customDelete - The customDelete object.
+     * @param customDelete.path - Path of the endpoint, for example `1/newFeature`.
+     * @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.
+     * @see customDelete for the plain version.
+     */
+    customDeleteWithHTTPInfo({ path, parameters }, requestOptions) {
+      validateRequired("path", "customDeleteWithHTTPInfo", path);
+      const requestPath = "/{path}".replace("{path}", path);
+      const headers = {};
+      const queryParameters = parameters ? parameters : {};
+      const request = {
+        method: "DELETE",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * This method lets you send requests to the Algolia REST API.
      * @param customGet - The customGet object.
@@ -367,6 +579,29 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     * @param customGet - The customGet object.
+     * @param customGet.path - Path of the endpoint, for example `1/newFeature`.
+     * @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.
+     * @see customGet for the plain version.
+     */
+    customGetWithHTTPInfo({ path, parameters }, requestOptions) {
+      validateRequired("path", "customGetWithHTTPInfo", path);
+      const requestPath = "/{path}".replace("{path}", path);
+      const headers = {};
+      const queryParameters = parameters ? parameters : {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * This method lets you send requests to the Algolia REST API.
      * @param customPost - The customPost object.
@@ -389,6 +624,31 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     * @param customPost - The customPost object.
+     * @param customPost.path - Path of the endpoint, for example `1/newFeature`.
+     * @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.
+     * @see customPost for the plain version.
+     */
+    customPostWithHTTPInfo({ path, parameters, body }, requestOptions) {
+      validateRequired("path", "customPostWithHTTPInfo", path);
+      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.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * This method lets you send requests to the Algolia REST API.
      * @param customPut - The customPut object.
@@ -411,6 +671,31 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     * @param customPut - The customPut object.
+     * @param customPut.path - Path of the endpoint, for example `1/newFeature`.
+     * @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.
+     * @see customPut for the plain version.
+     */
+    customPutWithHTTPInfo({ path, parameters, body }, requestOptions) {
+      validateRequired("path", "customPutWithHTTPInfo", path);
+      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.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Deletes an authentication resource. You can\'t delete authentication resources that are used by a source or a destination.
      *
@@ -439,21 +724,24 @@ function createIngestionClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Deletes a destination by its ID. You can\'t delete destinations that are referenced in tasks.
+     * Deletes an authentication resource. You can\'t delete authentication resources that are used by a source or a destination.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     * @param deleteDestination - The deleteDestination object.
-     * @param deleteDestination.destinationID - Unique identifier of a destination.
+     * @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.
+     * @see deleteAuthentication for the plain version.
      */
-    deleteDestination({ destinationID }, requestOptions) {
-      validateRequired("destinationID", "deleteDestination", destinationID);
-      const requestPath = "/1/destinations/{destinationID}".replace(
-        "{destinationID}",
-        encodeURIComponent(destinationID)
+    deleteAuthenticationWithHTTPInfo({ authenticationID }, requestOptions) {
+      validateRequired("authenticationID", "deleteAuthenticationWithHTTPInfo", authenticationID);
+      const requestPath = "/1/authentications/{authenticationID}".replace(
+        "{authenticationID}",
+        encodeURIComponent(authenticationID)
       );
       const headers = {};
       const queryParameters = {};
@@ -463,22 +751,25 @@ function createIngestionClient({
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * Deletes a source by its ID. You can\'t delete sources that are referenced in tasks.
+     * Deletes a destination by its ID. You can\'t delete destinations 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 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.
      */
-    deleteSource({ sourceID }, requestOptions) {
-      validateRequired("sourceID", "deleteSource", sourceID);
-      const requestPath = "/1/sources/{sourceID}".replace("{sourceID}", encodeURIComponent(sourceID));
+    deleteDestination({ destinationID }, requestOptions) {
+      validateRequired("destinationID", "deleteDestination", destinationID);
+      const requestPath = "/1/destinations/{destinationID}".replace(
+        "{destinationID}",
+        encodeURIComponent(destinationID)
+      );
       const headers = {};
       const queryParameters = {};
       const request = {
@@ -490,19 +781,25 @@ function createIngestionClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Deletes a task by its ID.
+     * Deletes a destination by its ID. You can\'t delete destinations that are referenced in tasks.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     * @param deleteTask - The deleteTask object.
-     * @param deleteTask.taskID - Unique identifier of a task.
+     * @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.
+     * @see deleteDestination for the plain version.
      */
-    deleteTask({ taskID }, requestOptions) {
-      validateRequired("taskID", "deleteTask", taskID);
-      const requestPath = "/2/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
+    deleteDestinationWithHTTPInfo({ destinationID }, requestOptions) {
+      validateRequired("destinationID", "deleteDestinationWithHTTPInfo", destinationID);
+      const requestPath = "/1/destinations/{destinationID}".replace(
+        "{destinationID}",
+        encodeURIComponent(destinationID)
+      );
       const headers = {};
       const queryParameters = {};
       const request = {
@@ -511,24 +808,22 @@ function createIngestionClient({
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * Deletes a task by its ID using the v1 endpoint. Use `deleteTask` instead.
+     * Deletes a source by its ID. You can\'t delete sources that are referenced in tasks.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     *
-     * @deprecated
-     * @param deleteTaskV1 - The deleteTaskV1 object.
-     * @param deleteTaskV1.taskID - Unique identifier of a task.
+     * @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.
      */
-    deleteTaskV1({ taskID }, requestOptions) {
-      validateRequired("taskID", "deleteTaskV1", taskID);
-      const requestPath = "/1/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
+    deleteSource({ sourceID }, requestOptions) {
+      validateRequired("sourceID", "deleteSource", sourceID);
+      const requestPath = "/1/sources/{sourceID}".replace("{sourceID}", encodeURIComponent(sourceID));
       const headers = {};
       const queryParameters = {};
       const request = {
@@ -540,22 +835,22 @@ function createIngestionClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Deletes a transformation by its ID.
+     * Deletes a source by its ID. You can\'t delete sources that are referenced in tasks.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     * @param deleteTransformation - The deleteTransformation object.
-     * @param deleteTransformation.transformationID - Unique identifier of a transformation.
+     * @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.
+     * @see deleteSource for the plain version.
      */
-    deleteTransformation({ transformationID }, requestOptions) {
-      validateRequired("transformationID", "deleteTransformation", transformationID);
-      const requestPath = "/1/transformations/{transformationID}".replace(
-        "{transformationID}",
-        encodeURIComponent(transformationID)
-      );
+    deleteSourceWithHTTPInfo({ sourceID }, requestOptions) {
+      validateRequired("sourceID", "deleteSourceWithHTTPInfo", sourceID);
+      const requestPath = "/1/sources/{sourceID}".replace("{sourceID}", encodeURIComponent(sourceID));
       const headers = {};
       const queryParameters = {};
       const request = {
@@ -564,26 +859,26 @@ function createIngestionClient({
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * Disables a task.
+     * Deletes a task by its ID.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     * @param disableTask - The disableTask object.
-     * @param disableTask.taskID - Unique identifier of a task.
+     * @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.
      */
-    disableTask({ taskID }, requestOptions) {
-      validateRequired("taskID", "disableTask", taskID);
-      const requestPath = "/2/tasks/{taskID}/disable".replace("{taskID}", encodeURIComponent(taskID));
+    deleteTask({ taskID }, requestOptions) {
+      validateRequired("taskID", "deleteTask", taskID);
+      const requestPath = "/2/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "PUT",
+        method: "DELETE",
         path: requestPath,
         queryParameters,
         headers
@@ -591,49 +886,52 @@ function createIngestionClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Disables a task using the v1 endpoint. Use `disableTask` instead.
+     * Deletes a task by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     *
-     * @deprecated
-     * @param disableTaskV1 - The disableTaskV1 object.
-     * @param disableTaskV1.taskID - Unique identifier of a task.
+     * @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.
+     * @see deleteTask for the plain version.
      */
-    disableTaskV1({ taskID }, requestOptions) {
-      validateRequired("taskID", "disableTaskV1", taskID);
-      const requestPath = "/1/tasks/{taskID}/disable".replace("{taskID}", encodeURIComponent(taskID));
+    deleteTaskWithHTTPInfo({ taskID }, requestOptions) {
+      validateRequired("taskID", "deleteTaskWithHTTPInfo", taskID);
+      const requestPath = "/2/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "PUT",
+        method: "DELETE",
         path: requestPath,
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * Enables a task.
+     * Deletes a task by its ID using the v1 endpoint. Use `deleteTask` instead.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     * @param enableTask - The enableTask object.
-     * @param enableTask.taskID - Unique identifier of a task.
+     *
+     * @deprecated
+     * @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.
      */
-    enableTask({ taskID }, requestOptions) {
-      validateRequired("taskID", "enableTask", taskID);
-      const requestPath = "/2/tasks/{taskID}/enable".replace("{taskID}", encodeURIComponent(taskID));
+    deleteTaskV1({ taskID }, requestOptions) {
+      validateRequired("taskID", "deleteTaskV1", taskID);
+      const requestPath = "/1/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "PUT",
+        method: "DELETE",
         path: requestPath,
         queryParameters,
         headers
@@ -641,7 +939,9 @@ function createIngestionClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Enables a task using the v1 endpoint. Use `enableTask` instead.
+     * Deletes a task by its ID using the v1 endpoint. Use `deleteTask` instead.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - addObject
@@ -649,44 +949,45 @@ function createIngestionClient({
      *  - editSettings
      *
      * @deprecated
-     * @param enableTaskV1 - The enableTaskV1 object.
-     * @param enableTaskV1.taskID - Unique identifier of a task.
+     * @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.
+     * @see deleteTaskV1 for the plain version.
      */
-    enableTaskV1({ taskID }, requestOptions) {
-      validateRequired("taskID", "enableTaskV1", taskID);
-      const requestPath = "/1/tasks/{taskID}/enable".replace("{taskID}", encodeURIComponent(taskID));
+    deleteTaskV1WithHTTPInfo({ taskID }, requestOptions) {
+      validateRequired("taskID", "deleteTaskV1WithHTTPInfo", taskID);
+      const requestPath = "/1/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "PUT",
+        method: "DELETE",
         path: requestPath,
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * Retrieves an authentication resource by its ID.
+     * Deletes a transformation 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 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.
      */
-    getAuthentication({ authenticationID }, requestOptions) {
-      validateRequired("authenticationID", "getAuthentication", authenticationID);
-      const requestPath = "/1/authentications/{authenticationID}".replace(
-        "{authenticationID}",
-        encodeURIComponent(authenticationID)
+    deleteTransformation({ transformationID }, requestOptions) {
+      validateRequired("transformationID", "deleteTransformation", transformationID);
+      const requestPath = "/1/transformations/{transformationID}".replace(
+        "{transformationID}",
+        encodeURIComponent(transformationID)
       );
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "GET",
+        method: "DELETE",
         path: requestPath,
         queryParameters,
         headers
@@ -694,52 +995,53 @@ function createIngestionClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Retrieves a destination by its ID.
+     * Deletes a transformation by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     * @param getDestination - The getDestination object.
-     * @param getDestination.destinationID - Unique identifier of a destination.
+     * @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.
+     * @see deleteTransformation for the plain version.
      */
-    getDestination({ destinationID }, requestOptions) {
-      validateRequired("destinationID", "getDestination", destinationID);
-      const requestPath = "/1/destinations/{destinationID}".replace(
-        "{destinationID}",
-        encodeURIComponent(destinationID)
+    deleteTransformationWithHTTPInfo({ transformationID }, requestOptions) {
+      validateRequired("transformationID", "deleteTransformationWithHTTPInfo", transformationID);
+      const requestPath = "/1/transformations/{transformationID}".replace(
+        "{transformationID}",
+        encodeURIComponent(transformationID)
       );
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "GET",
+        method: "DELETE",
         path: requestPath,
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * Retrieves a single task run event by its ID.
+     * Disables a task.
      *
      * 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 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.
      */
-    getEvent({ runID, eventID }, requestOptions) {
-      validateRequired("runID", "getEvent", runID);
-      validateRequired("eventID", "getEvent", eventID);
-      const requestPath = "/1/runs/{runID}/events/{eventID}".replace("{runID}", encodeURIComponent(runID)).replace("{eventID}", encodeURIComponent(eventID));
+    disableTask({ taskID }, requestOptions) {
+      validateRequired("taskID", "disableTask", taskID);
+      const requestPath = "/2/tasks/{taskID}/disable".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "GET",
+        method: "PUT",
         path: requestPath,
         queryParameters,
         headers
@@ -747,47 +1049,52 @@ function createIngestionClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Retrieve a single task run by its ID.
+     * Disables a task.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     * @param getRun - The getRun object.
-     * @param getRun.runID - Unique identifier of a task run.
+     * @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.
+     * @see disableTask for the plain version.
      */
-    getRun({ runID }, requestOptions) {
-      validateRequired("runID", "getRun", runID);
-      const requestPath = "/1/runs/{runID}".replace("{runID}", encodeURIComponent(runID));
+    disableTaskWithHTTPInfo({ taskID }, requestOptions) {
+      validateRequired("taskID", "disableTaskWithHTTPInfo", taskID);
+      const requestPath = "/2/tasks/{taskID}/disable".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "GET",
+        method: "PUT",
         path: requestPath,
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * Retrieve a source by its ID.
+     * Disables a task using the v1 endpoint. Use `disableTask` instead.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     * @param getSource - The getSource object.
-     * @param getSource.sourceID - Unique identifier of a source.
+     *
+     * @deprecated
+     * @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.
      */
-    getSource({ sourceID }, requestOptions) {
-      validateRequired("sourceID", "getSource", sourceID);
-      const requestPath = "/1/sources/{sourceID}".replace("{sourceID}", encodeURIComponent(sourceID));
+    disableTaskV1({ taskID }, requestOptions) {
+      validateRequired("taskID", "disableTaskV1", taskID);
+      const requestPath = "/1/tasks/{taskID}/disable".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "GET",
+        method: "PUT",
         path: requestPath,
         queryParameters,
         headers
@@ -795,49 +1102,52 @@ function createIngestionClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Retrieves a task by its ID.
+     * Disables a task using the v1 endpoint. Use `disableTask` instead.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     * @param getTask - The getTask object.
-     * @param getTask.taskID - Unique identifier of a task.
+     *
+     * @deprecated
+     * @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.
+     * @see disableTaskV1 for the plain version.
      */
-    getTask({ taskID }, requestOptions) {
-      validateRequired("taskID", "getTask", taskID);
-      const requestPath = "/2/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
+    disableTaskV1WithHTTPInfo({ taskID }, requestOptions) {
+      validateRequired("taskID", "disableTaskV1WithHTTPInfo", taskID);
+      const requestPath = "/1/tasks/{taskID}/disable".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "GET",
+        method: "PUT",
         path: requestPath,
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * Retrieves a task by its ID using the v1 endpoint. Use `getTask` instead.
+     * Enables a task.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     *
-     * @deprecated
-     * @param getTaskV1 - The getTaskV1 object.
-     * @param getTaskV1.taskID - Unique identifier of a task.
+     * @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.
      */
-    getTaskV1({ taskID }, requestOptions) {
-      validateRequired("taskID", "getTaskV1", taskID);
-      const requestPath = "/1/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
+    enableTask({ taskID }, requestOptions) {
+      validateRequired("taskID", "enableTask", taskID);
+      const requestPath = "/2/tasks/{taskID}/enable".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "GET",
+        method: "PUT",
         path: requestPath,
         queryParameters,
         headers
@@ -845,63 +1155,651 @@ function createIngestionClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Retrieves a transformation by its ID.
+     * Enables a task.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
      *  - editSettings
-     * @param getTransformation - The getTransformation object.
-     * @param getTransformation.transformationID - Unique identifier of a transformation.
+     * @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.
+     * @see enableTask for the plain version.
      */
-    getTransformation({ transformationID }, requestOptions) {
-      validateRequired("transformationID", "getTransformation", transformationID);
-      const requestPath = "/1/transformations/{transformationID}".replace(
-        "{transformationID}",
-        encodeURIComponent(transformationID)
-      );
+    enableTaskWithHTTPInfo({ taskID }, requestOptions) {
+      validateRequired("taskID", "enableTaskWithHTTPInfo", taskID);
+      const requestPath = "/2/tasks/{taskID}/enable".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
-        method: "GET",
+        method: "PUT",
         path: requestPath,
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * Retrieves a list of all authentication resources.
+     * Enables a task using the v1 endpoint. Use `enableTask` instead.
      *
      * 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 authentications.
-     * @param listAuthentications.sort - Property by which to sort the list of authentications.
-     * @param listAuthentications.order - Sort order of the response, ascending or descending.
+     *
+     * @deprecated
+     * @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.
      */
-    listAuthentications({ itemsPerPage, page, type, platform, sort, order } = {}, requestOptions = void 0) {
-      const requestPath = "/1/authentications";
+    enableTaskV1({ taskID }, requestOptions) {
+      validateRequired("taskID", "enableTaskV1", taskID);
+      const requestPath = "/1/tasks/{taskID}/enable".replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
-      if (itemsPerPage !== void 0) {
-        queryParameters["itemsPerPage"] = itemsPerPage.toString();
-      }
-      if (page !== void 0) {
-        queryParameters["page"] = page.toString();
-      }
-      if (type !== void 0) {
-        queryParameters["type"] = type.toString();
-      }
-      if (platform !== void 0) {
-        queryParameters["platform"] = platform.toString();
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.request(request, requestOptions);
+    },
+    /**
+     * Enables a task using the v1 endpoint. Use `enableTask` instead.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     *
+     * @deprecated
+     * @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.
+     * @see enableTaskV1 for the plain version.
+     */
+    enableTaskV1WithHTTPInfo({ taskID }, requestOptions) {
+      validateRequired("taskID", "enableTaskV1WithHTTPInfo", taskID);
+      const requestPath = "/1/tasks/{taskID}/enable".replace("{taskID}", encodeURIComponent(taskID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(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) {
+      validateRequired("authenticationID", "getAuthentication", authenticationID);
+      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 an authentication resource by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see getAuthentication for the plain version.
+     */
+    getAuthenticationWithHTTPInfo({ authenticationID }, requestOptions) {
+      validateRequired("authenticationID", "getAuthenticationWithHTTPInfo", authenticationID);
+      const requestPath = "/1/authentications/{authenticationID}".replace(
+        "{authenticationID}",
+        encodeURIComponent(authenticationID)
+      );
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(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) {
+      validateRequired("destinationID", "getDestination", destinationID);
+      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 destination by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see getDestination for the plain version.
+     */
+    getDestinationWithHTTPInfo({ destinationID }, requestOptions) {
+      validateRequired("destinationID", "getDestinationWithHTTPInfo", destinationID);
+      const requestPath = "/1/destinations/{destinationID}".replace(
+        "{destinationID}",
+        encodeURIComponent(destinationID)
+      );
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(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) {
+      validateRequired("runID", "getEvent", runID);
+      validateRequired("eventID", "getEvent", eventID);
+      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);
+    },
+    /**
+     * Retrieves a single task run event by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see getEvent for the plain version.
+     */
+    getEventWithHTTPInfo({ runID, eventID }, requestOptions) {
+      validateRequired("runID", "getEventWithHTTPInfo", runID);
+      validateRequired("eventID", "getEventWithHTTPInfo", eventID);
+      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.requestWithHttpInfo(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) {
+      validateRequired("runID", "getRun", runID);
+      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 single task run by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see getRun for the plain version.
+     */
+    getRunWithHTTPInfo({ runID }, requestOptions) {
+      validateRequired("runID", "getRunWithHTTPInfo", runID);
+      const requestPath = "/1/runs/{runID}".replace("{runID}", encodeURIComponent(runID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(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) {
+      validateRequired("sourceID", "getSource", sourceID);
+      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);
+    },
+    /**
+     * Retrieve a source by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see getSource for the plain version.
+     */
+    getSourceWithHTTPInfo({ sourceID }, requestOptions) {
+      validateRequired("sourceID", "getSourceWithHTTPInfo", sourceID);
+      const requestPath = "/1/sources/{sourceID}".replace("{sourceID}", encodeURIComponent(sourceID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(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) {
+      validateRequired("taskID", "getTask", taskID);
+      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.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see getTask for the plain version.
+     */
+    getTaskWithHTTPInfo({ taskID }, requestOptions) {
+      validateRequired("taskID", "getTaskWithHTTPInfo", taskID);
+      const requestPath = "/2/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * Retrieves a task by its ID using the v1 endpoint. Use `getTask` instead.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     *
+     * @deprecated
+     * @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) {
+      validateRequired("taskID", "getTaskV1", taskID);
+      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 task by its ID using the v1 endpoint. Use `getTask` instead.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     *
+     * @deprecated
+     * @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.
+     * @see getTaskV1 for the plain version.
+     */
+    getTaskV1WithHTTPInfo({ taskID }, requestOptions) {
+      validateRequired("taskID", "getTaskV1WithHTTPInfo", taskID);
+      const requestPath = "/1/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(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) {
+      validateRequired("transformationID", "getTransformation", transformationID);
+      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 transformation by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see getTransformation for the plain version.
+     */
+    getTransformationWithHTTPInfo({ transformationID }, requestOptions) {
+      validateRequired("transformationID", "getTransformationWithHTTPInfo", transformationID);
+      const requestPath = "/1/transformations/{transformationID}".replace(
+        "{transformationID}",
+        encodeURIComponent(transformationID)
+      );
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(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 authentications.
+     * @param listAuthentications.sort - Property by which to sort the list of authentications.
+     * @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 = void 0) {
+      const requestPath = "/1/authentications";
+      const headers = {};
+      const queryParameters = {};
+      if (itemsPerPage !== void 0) {
+        queryParameters["itemsPerPage"] = itemsPerPage.toString();
+      }
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (type !== void 0) {
+        queryParameters["type"] = type.toString();
+      }
+      if (platform !== void 0) {
+        queryParameters["platform"] = platform.toString();
+      }
+      if (sort !== void 0) {
+        queryParameters["sort"] = sort.toString();
+      }
+      if (order !== void 0) {
+        queryParameters["order"] = order.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.request(request, requestOptions);
+    },
+    /**
+     * Retrieves a list of all authentication resources.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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 authentications.
+     * @param listAuthentications.sort - Property by which to sort the list of authentications.
+     * @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.
+     * @see listAuthentications for the plain version.
+     */
+    listAuthenticationsWithHTTPInfo({ itemsPerPage, page, type, platform, sort, order } = {}, requestOptions = void 0) {
+      const requestPath = "/1/authentications";
+      const headers = {};
+      const queryParameters = {};
+      if (itemsPerPage !== void 0) {
+        queryParameters["itemsPerPage"] = itemsPerPage.toString();
+      }
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (type !== void 0) {
+        queryParameters["type"] = type.toString();
+      }
+      if (platform !== void 0) {
+        queryParameters["platform"] = platform.toString();
+      }
+      if (sort !== void 0) {
+        queryParameters["sort"] = sort.toString();
+      }
+      if (order !== void 0) {
+        queryParameters["order"] = order.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(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.transformationID - Get the list of destinations used by a transformation.
+     * @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, transformationID, sort, order } = {}, requestOptions = void 0) {
+      const requestPath = "/1/destinations";
+      const headers = {};
+      const queryParameters = {};
+      if (itemsPerPage !== void 0) {
+        queryParameters["itemsPerPage"] = itemsPerPage.toString();
+      }
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (type !== void 0) {
+        queryParameters["type"] = type.toString();
+      }
+      if (authenticationID !== void 0) {
+        queryParameters["authenticationID"] = authenticationID.toString();
+      }
+      if (transformationID !== void 0) {
+        queryParameters["transformationID"] = transformationID.toString();
       }
       if (sort !== void 0) {
         queryParameters["sort"] = sort.toString();
@@ -920,6 +1818,8 @@ function createIngestionClient({
     /**
      * Retrieves a list of destinations.
      *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
@@ -933,8 +1833,9 @@ function createIngestionClient({
      * @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.
+     * @see listDestinations for the plain version.
      */
-    listDestinations({ itemsPerPage, page, type, authenticationID, transformationID, sort, order } = {}, requestOptions = void 0) {
+    listDestinationsWithHTTPInfo({ itemsPerPage, page, type, authenticationID, transformationID, sort, order } = {}, requestOptions = void 0) {
       const requestPath = "/1/destinations";
       const headers = {};
       const queryParameters = {};
@@ -965,7 +1866,7 @@ function createIngestionClient({
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
      * Retrieves a list of events for a task run, identified by its ID.
@@ -1023,6 +1924,65 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Retrieves a list of events for a task run, identified by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see listEvents for the plain version.
+     */
+    listEventsWithHTTPInfo({ runID, itemsPerPage, page, status, type, sort, order, startDate, endDate }, requestOptions) {
+      validateRequired("runID", "listEventsWithHTTPInfo", runID);
+      const requestPath = "/1/runs/{runID}/events".replace("{runID}", encodeURIComponent(runID));
+      const headers = {};
+      const queryParameters = {};
+      if (itemsPerPage !== void 0) {
+        queryParameters["itemsPerPage"] = itemsPerPage.toString();
+      }
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (status !== void 0) {
+        queryParameters["status"] = status.toString();
+      }
+      if (type !== void 0) {
+        queryParameters["type"] = type.toString();
+      }
+      if (sort !== void 0) {
+        queryParameters["sort"] = sort.toString();
+      }
+      if (order !== void 0) {
+        queryParameters["order"] = order.toString();
+      }
+      if (startDate !== void 0) {
+        queryParameters["startDate"] = startDate.toString();
+      }
+      if (endDate !== void 0) {
+        queryParameters["endDate"] = endDate.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Retrieve a list of task runs.
      *
@@ -1081,6 +2041,67 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Retrieve a list of task runs.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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 and time for the earliest run to retrieve, in RFC 3339 format. By default, the current day minus seven days is used.
+     * @param listRuns.endDate - Date and time for the latest run to retrieve, in RFC 3339 format. 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.
+     * @see listRuns for the plain version.
+     */
+    listRunsWithHTTPInfo({ itemsPerPage, page, status, type, taskID, sort, order, startDate, endDate } = {}, requestOptions = void 0) {
+      const requestPath = "/1/runs";
+      const headers = {};
+      const queryParameters = {};
+      if (itemsPerPage !== void 0) {
+        queryParameters["itemsPerPage"] = itemsPerPage.toString();
+      }
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (status !== void 0) {
+        queryParameters["status"] = status.toString();
+      }
+      if (type !== void 0) {
+        queryParameters["type"] = type.toString();
+      }
+      if (taskID !== void 0) {
+        queryParameters["taskID"] = taskID.toString();
+      }
+      if (sort !== void 0) {
+        queryParameters["sort"] = sort.toString();
+      }
+      if (order !== void 0) {
+        queryParameters["order"] = order.toString();
+      }
+      if (startDate !== void 0) {
+        queryParameters["startDate"] = startDate.toString();
+      }
+      if (endDate !== void 0) {
+        queryParameters["endDate"] = endDate.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Retrieves a list of sources.
      *
@@ -1107,11 +2128,138 @@ function createIngestionClient({
       if (page !== void 0) {
         queryParameters["page"] = page.toString();
       }
-      if (type !== void 0) {
-        queryParameters["type"] = type.toString();
+      if (type !== void 0) {
+        queryParameters["type"] = type.toString();
+      }
+      if (authenticationID !== void 0) {
+        queryParameters["authenticationID"] = authenticationID.toString();
+      }
+      if (sort !== void 0) {
+        queryParameters["sort"] = sort.toString();
+      }
+      if (order !== void 0) {
+        queryParameters["order"] = order.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.request(request, requestOptions);
+    },
+    /**
+     * Retrieves a list of sources.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @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.
+     * @see listSources for the plain version.
+     */
+    listSourcesWithHTTPInfo({ itemsPerPage, page, type, authenticationID, sort, order } = {}, requestOptions = void 0) {
+      const requestPath = "/1/sources";
+      const headers = {};
+      const queryParameters = {};
+      if (itemsPerPage !== void 0) {
+        queryParameters["itemsPerPage"] = itemsPerPage.toString();
+      }
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (type !== void 0) {
+        queryParameters["type"] = type.toString();
+      }
+      if (authenticationID !== void 0) {
+        queryParameters["authenticationID"] = authenticationID.toString();
+      }
+      if (sort !== void 0) {
+        queryParameters["sort"] = sort.toString();
+      }
+      if (order !== void 0) {
+        queryParameters["order"] = order.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(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.sourceType - Filters the tasks with the specified source type.
+     * @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.withEmailNotifications - If specified, the response only includes tasks with notifications.email.enabled set to this value.
+     * @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,
+      sourceType,
+      destinationID,
+      triggerType,
+      withEmailNotifications,
+      sort,
+      order
+    } = {}, requestOptions = void 0) {
+      const requestPath = "/2/tasks";
+      const headers = {};
+      const queryParameters = {};
+      if (itemsPerPage !== void 0) {
+        queryParameters["itemsPerPage"] = itemsPerPage.toString();
+      }
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (action !== void 0) {
+        queryParameters["action"] = action.toString();
       }
-      if (authenticationID !== void 0) {
-        queryParameters["authenticationID"] = authenticationID.toString();
+      if (enabled !== void 0) {
+        queryParameters["enabled"] = enabled.toString();
+      }
+      if (sourceID !== void 0) {
+        queryParameters["sourceID"] = sourceID.toString();
+      }
+      if (sourceType !== void 0) {
+        queryParameters["sourceType"] = sourceType.toString();
+      }
+      if (destinationID !== void 0) {
+        queryParameters["destinationID"] = destinationID.toString();
+      }
+      if (triggerType !== void 0) {
+        queryParameters["triggerType"] = triggerType.toString();
+      }
+      if (withEmailNotifications !== void 0) {
+        queryParameters["withEmailNotifications"] = withEmailNotifications.toString();
       }
       if (sort !== void 0) {
         queryParameters["sort"] = sort.toString();
@@ -1130,6 +2278,8 @@ function createIngestionClient({
     /**
      * Retrieves a list of tasks.
      *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
@@ -1147,8 +2297,9 @@ function createIngestionClient({
      * @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.
+     * @see listTasks for the plain version.
      */
-    listTasks({
+    listTasksWithHTTPInfo({
       itemsPerPage,
       page,
       action,
@@ -1203,7 +2354,7 @@ function createIngestionClient({
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
      * Retrieves a list of tasks using the v1 endpoint. Use `getTasks` instead.
@@ -1265,6 +2416,69 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Retrieves a list of tasks using the v1 endpoint. Use `getTasks` instead.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     *
+     * @deprecated
+     * @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.
+     * @see listTasksV1 for the plain version.
+     */
+    listTasksV1WithHTTPInfo({ itemsPerPage, page, action, enabled, sourceID, destinationID, triggerType, sort, order } = {}, requestOptions = void 0) {
+      const requestPath = "/1/tasks";
+      const headers = {};
+      const queryParameters = {};
+      if (itemsPerPage !== void 0) {
+        queryParameters["itemsPerPage"] = itemsPerPage.toString();
+      }
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (action !== void 0) {
+        queryParameters["action"] = action.toString();
+      }
+      if (enabled !== void 0) {
+        queryParameters["enabled"] = enabled.toString();
+      }
+      if (sourceID !== void 0) {
+        queryParameters["sourceID"] = sourceID.toString();
+      }
+      if (destinationID !== void 0) {
+        queryParameters["destinationID"] = destinationID.toString();
+      }
+      if (triggerType !== void 0) {
+        queryParameters["triggerType"] = triggerType.toString();
+      }
+      if (sort !== void 0) {
+        queryParameters["sort"] = sort.toString();
+      }
+      if (order !== void 0) {
+        queryParameters["order"] = order.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Retrieves a list of transformations.
      *
@@ -1307,6 +2521,51 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Retrieves a list of transformations.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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 of transformations.
+     * @param listTransformations.order - Sort order of the response, ascending or descending.
+     * @param listTransformations.type - Whether to filter the list of transformations by the type of transformation.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see listTransformations for the plain version.
+     */
+    listTransformationsWithHTTPInfo({ itemsPerPage, page, sort, order, type } = {}, requestOptions = void 0) {
+      const requestPath = "/1/transformations";
+      const headers = {};
+      const queryParameters = {};
+      if (itemsPerPage !== void 0) {
+        queryParameters["itemsPerPage"] = itemsPerPage.toString();
+      }
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (sort !== void 0) {
+        queryParameters["sort"] = sort.toString();
+      }
+      if (order !== void 0) {
+        queryParameters["order"] = order.toString();
+      }
+      if (type !== void 0) {
+        queryParameters["type"] = type.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Pushes records through the Pipeline, directly to an index. You can make the call synchronous by providing the `watch` parameter, for asynchronous calls, you can use the observability endpoints and/or debugger dashboard to see the status of your task. If you want to leverage the [pre-indexing data transformation](https://www.algolia.com/doc/guides/sending-and-managing-data/send-and-update-your-data/how-to/transform-your-data), this is the recommended way of ingesting your records. This method is similar to `pushTask`, but requires an `indexName` instead of a `taskID`. If zero or many tasks are found, an error will be returned.
      *
@@ -1343,6 +2602,7 @@ function createIngestionClient({
         data: pushTaskPayload
       };
       requestOptions = {
+        ...requestOptions,
         timeouts: {
           connect: 18e4,
           read: 18e4,
@@ -1352,6 +2612,55 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Pushes records through the Pipeline, directly to an index. You can make the call synchronous by providing the `watch` parameter, for asynchronous calls, you can use the observability endpoints and/or debugger dashboard to see the status of your task. If you want to leverage the [pre-indexing data transformation](https://www.algolia.com/doc/guides/sending-and-managing-data/send-and-update-your-data/how-to/transform-your-data), this is the recommended way of ingesting your records. This method is similar to `pushTask`, but requires an `indexName` instead of a `taskID`. If zero or many tasks are found, an error will be returned.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     * @param push - The push object.
+     * @param push.indexName - Name of the index on which to perform the operation.
+     * @param push.pushTaskPayload - The pushTaskPayload object.
+     * @param push.watch - When provided, the push operation will be synchronous and the API will wait for the ingestion to be finished before responding.
+     * @param push.referenceIndexName - This is required when targeting an index that does not have a push connector setup (e.g. a tmp index), but you wish to attach another index\'s transformation to it (e.g. the source index name).
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see push for the plain version.
+     */
+    pushWithHTTPInfo({ indexName, pushTaskPayload, watch, referenceIndexName }, requestOptions) {
+      validateRequired("indexName", "pushWithHTTPInfo", indexName);
+      validateRequired("pushTaskPayload", "pushWithHTTPInfo", pushTaskPayload);
+      validateRequired("pushTaskPayload.action", "pushWithHTTPInfo", pushTaskPayload.action);
+      validateRequired("pushTaskPayload.records", "pushWithHTTPInfo", pushTaskPayload.records);
+      const requestPath = "/1/push/{indexName}".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      if (watch !== void 0) {
+        queryParameters["watch"] = watch.toString();
+      }
+      if (referenceIndexName !== void 0) {
+        queryParameters["referenceIndexName"] = referenceIndexName.toString();
+      }
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: pushTaskPayload
+      };
+      requestOptions = {
+        ...requestOptions,
+        timeouts: {
+          connect: 18e4,
+          read: 18e4,
+          write: 18e4,
+          ...requestOptions == null ? void 0 : requestOptions.timeouts
+        }
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Pushes records through the pipeline, directly to an index. You can make the call synchronous by providing the `watch` parameter, for asynchronous calls, you can use the observability endpoints or the debugger dashboard to see the status of your task. If you want to transform your data before indexing, this is the recommended way of ingesting your records. This method is similar to `push`, but requires a `taskID` instead of a `indexName`, which is useful when many `destinations` target the same `indexName`.
      *
@@ -1384,6 +2693,7 @@ function createIngestionClient({
         data: pushTaskPayload
       };
       requestOptions = {
+        ...requestOptions,
         timeouts: {
           connect: 18e4,
           read: 18e4,
@@ -1393,6 +2703,51 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Pushes records through the pipeline, directly to an index. You can make the call synchronous by providing the `watch` parameter, for asynchronous calls, you can use the observability endpoints or the debugger dashboard to see the status of your task. If you want to transform your data before indexing, this is the recommended way of ingesting your records. This method is similar to `push`, but requires a `taskID` instead of a `indexName`, which is useful when many `destinations` target the same `indexName`.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     * @param pushTask - The pushTask object.
+     * @param pushTask.taskID - Unique identifier of a task.
+     * @param pushTask.pushTaskPayload - The pushTaskPayload object.
+     * @param pushTask.watch - When provided, the push operation will be synchronous and the API will wait for the ingestion to be finished before responding.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see pushTask for the plain version.
+     */
+    pushTaskWithHTTPInfo({ taskID, pushTaskPayload, watch }, requestOptions) {
+      validateRequired("taskID", "pushTaskWithHTTPInfo", taskID);
+      validateRequired("pushTaskPayload", "pushTaskWithHTTPInfo", pushTaskPayload);
+      validateRequired("pushTaskPayload.action", "pushTaskWithHTTPInfo", pushTaskPayload.action);
+      validateRequired("pushTaskPayload.records", "pushTaskWithHTTPInfo", pushTaskPayload.records);
+      const requestPath = "/2/tasks/{taskID}/push".replace("{taskID}", encodeURIComponent(taskID));
+      const headers = {};
+      const queryParameters = {};
+      if (watch !== void 0) {
+        queryParameters["watch"] = watch.toString();
+      }
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: pushTaskPayload
+      };
+      requestOptions = {
+        ...requestOptions,
+        timeouts: {
+          connect: 18e4,
+          read: 18e4,
+          write: 18e4,
+          ...requestOptions == null ? void 0 : requestOptions.timeouts
+        }
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Fully updates a task by its ID, use partialUpdateTask if you only want to update a subset of fields.
      *
@@ -1418,13 +2773,73 @@ function createIngestionClient({
         path: requestPath,
         queryParameters,
         headers,
-        data: taskReplace
+        data: taskReplace
+      };
+      return transporter.request(request, requestOptions);
+    },
+    /**
+     * Fully updates a task by its ID, use partialUpdateTask if you only want to update a subset of fields.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     * @param replaceTask - The replaceTask object.
+     * @param replaceTask.taskID - Unique identifier of a task.
+     * @param replaceTask.taskReplace - The taskReplace object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see replaceTask for the plain version.
+     */
+    replaceTaskWithHTTPInfo({ taskID, taskReplace }, requestOptions) {
+      validateRequired("taskID", "replaceTaskWithHTTPInfo", taskID);
+      validateRequired("taskReplace", "replaceTaskWithHTTPInfo", taskReplace);
+      validateRequired("taskReplace.destinationID", "replaceTaskWithHTTPInfo", taskReplace.destinationID);
+      validateRequired("taskReplace.action", "replaceTaskWithHTTPInfo", taskReplace.action);
+      const requestPath = "/2/tasks/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: taskReplace
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * Runs all tasks linked to a source, only available for Shopify, BigCommerce and commercetools sources. Creates one 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) {
+      validateRequired("sourceID", "runSource", sourceID);
+      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 all tasks linked to a source, only available for Shopify, BigCommerce and commercetools sources. Creates one run per task.
      *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
      * Required API Key ACLs:
      *  - addObject
      *  - deleteIndex
@@ -1433,9 +2848,10 @@ function createIngestionClient({
      * @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.
+     * @see runSource for the plain version.
      */
-    runSource({ sourceID, runSourcePayload }, requestOptions) {
-      validateRequired("sourceID", "runSource", sourceID);
+    runSourceWithHTTPInfo({ sourceID, runSourcePayload }, requestOptions) {
+      validateRequired("sourceID", "runSourceWithHTTPInfo", sourceID);
       const requestPath = "/1/sources/{sourceID}/run".replace("{sourceID}", encodeURIComponent(sourceID));
       const headers = {};
       const queryParameters = {};
@@ -1446,7 +2862,7 @@ function createIngestionClient({
         headers,
         data: runSourcePayload ? runSourcePayload : {}
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
      * Runs a task. You can check the status of task runs with the observability endpoints.
@@ -1474,6 +2890,35 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Runs a task. You can check the status of task runs with the observability endpoints.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     * @param runTask - The runTask object.
+     * @param runTask.taskID - Unique identifier of a task.
+     * @param runTask.runTaskPayload -
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see runTask for the plain version.
+     */
+    runTaskWithHTTPInfo({ taskID, runTaskPayload }, requestOptions) {
+      validateRequired("taskID", "runTaskWithHTTPInfo", taskID);
+      const requestPath = "/2/tasks/{taskID}/run".replace("{taskID}", encodeURIComponent(taskID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: runTaskPayload ? runTaskPayload : {}
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Runs a task using the v1 endpoint. Use `runTask` instead. You can check the status of task runs with the observability endpoints.
      *
@@ -1502,6 +2947,37 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Runs a task using the v1 endpoint. Use `runTask` instead. You can check the status of task runs with the observability endpoints.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     *
+     * @deprecated
+     * @param runTaskV1 - The runTaskV1 object.
+     * @param runTaskV1.taskID - Unique identifier of a task.
+     * @param runTaskV1.runTaskPayload -
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see runTaskV1 for the plain version.
+     */
+    runTaskV1WithHTTPInfo({ taskID, runTaskPayload }, requestOptions) {
+      validateRequired("taskID", "runTaskV1WithHTTPInfo", taskID);
+      const requestPath = "/1/tasks/{taskID}/run".replace("{taskID}", encodeURIComponent(taskID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: runTaskPayload ? runTaskPayload : {}
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Searches for authentication resources.
      *
@@ -1531,6 +3007,38 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches for authentication resources.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see searchAuthentications for the plain version.
+     */
+    searchAuthenticationsWithHTTPInfo(authenticationSearch, requestOptions) {
+      validateRequired("authenticationSearch", "searchAuthenticationsWithHTTPInfo", authenticationSearch);
+      validateRequired(
+        "authenticationSearch.authenticationIDs",
+        "searchAuthenticationsWithHTTPInfo",
+        authenticationSearch.authenticationIDs
+      );
+      const requestPath = "/1/authentications/search";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: authenticationSearch
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Searches for destinations.
      *
@@ -1556,6 +3064,38 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches for destinations.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see searchDestinations for the plain version.
+     */
+    searchDestinationsWithHTTPInfo(destinationSearch, requestOptions) {
+      validateRequired("destinationSearch", "searchDestinationsWithHTTPInfo", destinationSearch);
+      validateRequired(
+        "destinationSearch.destinationIDs",
+        "searchDestinationsWithHTTPInfo",
+        destinationSearch.destinationIDs
+      );
+      const requestPath = "/1/destinations/search";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: destinationSearch
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Searches for sources.
      *
@@ -1581,6 +3121,34 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches for sources.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see searchSources for the plain version.
+     */
+    searchSourcesWithHTTPInfo(sourceSearch, requestOptions) {
+      validateRequired("sourceSearch", "searchSourcesWithHTTPInfo", sourceSearch);
+      validateRequired("sourceSearch.sourceIDs", "searchSourcesWithHTTPInfo", sourceSearch.sourceIDs);
+      const requestPath = "/1/sources/search";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: sourceSearch
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Searches for tasks.
      *
@@ -1606,6 +3174,34 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches for tasks.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see searchTasks for the plain version.
+     */
+    searchTasksWithHTTPInfo(taskSearch, requestOptions) {
+      validateRequired("taskSearch", "searchTasksWithHTTPInfo", taskSearch);
+      validateRequired("taskSearch.taskIDs", "searchTasksWithHTTPInfo", taskSearch.taskIDs);
+      const requestPath = "/2/tasks/search";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: taskSearch
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Searches for tasks using the v1 endpoint. Use `searchTasks` instead.
      *
@@ -1633,6 +3229,36 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches for tasks using the v1 endpoint. Use `searchTasks` instead.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     *
+     * @deprecated
+     * @param taskSearch - The taskSearch object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see searchTasksV1 for the plain version.
+     */
+    searchTasksV1WithHTTPInfo(taskSearch, requestOptions) {
+      validateRequired("taskSearch", "searchTasksV1WithHTTPInfo", taskSearch);
+      validateRequired("taskSearch.taskIDs", "searchTasksV1WithHTTPInfo", taskSearch.taskIDs);
+      const requestPath = "/1/tasks/search";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: taskSearch
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Searches for transformations.
      *
@@ -1662,6 +3288,38 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches for transformations.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see searchTransformations for the plain version.
+     */
+    searchTransformationsWithHTTPInfo(transformationSearch, requestOptions) {
+      validateRequired("transformationSearch", "searchTransformationsWithHTTPInfo", transformationSearch);
+      validateRequired(
+        "transformationSearch.transformationIDs",
+        "searchTransformationsWithHTTPInfo",
+        transformationSearch.transformationIDs
+      );
+      const requestPath = "/1/transformations/search";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: transformationSearch
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Triggers a stream-listing request for a source. Triggering stream-listing requests only works with sources with `type: docker` and `imageType: airbyte`.
      *
@@ -1685,6 +3343,43 @@ function createIngestionClient({
         headers
       };
       requestOptions = {
+        ...requestOptions,
+        timeouts: {
+          connect: 18e4,
+          read: 18e4,
+          write: 18e4,
+          ...requestOptions == null ? void 0 : requestOptions.timeouts
+        }
+      };
+      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: airbyte`.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see triggerDockerSourceDiscover for the plain version.
+     */
+    triggerDockerSourceDiscoverWithHTTPInfo({ sourceID }, requestOptions) {
+      validateRequired("sourceID", "triggerDockerSourceDiscoverWithHTTPInfo", sourceID);
+      const requestPath = "/1/sources/{sourceID}/discover".replace("{sourceID}", encodeURIComponent(sourceID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      requestOptions = {
+        ...requestOptions,
         timeouts: {
           connect: 18e4,
           read: 18e4,
@@ -1692,21 +3387,53 @@ function createIngestionClient({
           ...requestOptions == null ? void 0 : requestOptions.timeouts
         }
       };
+      return transporter.requestWithHttpInfo(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) {
+      validateRequired("transformationTry", "tryTransformation", transformationTry);
+      validateRequired("transformationTry.sampleRecord", "tryTransformation", transformationTry.sampleRecord);
+      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 creating it.
      *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
      * 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.
+     * @see tryTransformation for the plain version.
      */
-    tryTransformation(transformationTry, requestOptions) {
-      validateRequired("transformationTry", "tryTransformation", transformationTry);
-      validateRequired("transformationTry.sampleRecord", "tryTransformation", transformationTry.sampleRecord);
+    tryTransformationWithHTTPInfo(transformationTry, requestOptions) {
+      validateRequired("transformationTry", "tryTransformationWithHTTPInfo", transformationTry);
+      validateRequired(
+        "transformationTry.sampleRecord",
+        "tryTransformationWithHTTPInfo",
+        transformationTry.sampleRecord
+      );
       const requestPath = "/1/transformations/try";
       const headers = {};
       const queryParameters = {};
@@ -1717,7 +3444,7 @@ function createIngestionClient({
         headers,
         data: transformationTry
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
      * Try a transformation before updating it.
@@ -1754,6 +3481,44 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Try a transformation before updating it.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see tryTransformationBeforeUpdate for the plain version.
+     */
+    tryTransformationBeforeUpdateWithHTTPInfo({ transformationID, transformationTry }, requestOptions) {
+      validateRequired("transformationID", "tryTransformationBeforeUpdateWithHTTPInfo", transformationID);
+      validateRequired("transformationTry", "tryTransformationBeforeUpdateWithHTTPInfo", transformationTry);
+      validateRequired(
+        "transformationTry.sampleRecord",
+        "tryTransformationBeforeUpdateWithHTTPInfo",
+        transformationTry.sampleRecord
+      );
+      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.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Updates an authentication resource.
      *
@@ -1784,6 +3549,39 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Updates an authentication resource.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see updateAuthentication for the plain version.
+     */
+    updateAuthenticationWithHTTPInfo({ authenticationID, authenticationUpdate }, requestOptions) {
+      validateRequired("authenticationID", "updateAuthenticationWithHTTPInfo", authenticationID);
+      validateRequired("authenticationUpdate", "updateAuthenticationWithHTTPInfo", authenticationUpdate);
+      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.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Updates the destination by its ID.
      *
@@ -1814,6 +3612,39 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Updates the destination by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see updateDestination for the plain version.
+     */
+    updateDestinationWithHTTPInfo({ destinationID, destinationUpdate }, requestOptions) {
+      validateRequired("destinationID", "updateDestinationWithHTTPInfo", destinationID);
+      validateRequired("destinationUpdate", "updateDestinationWithHTTPInfo", destinationUpdate);
+      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.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Updates a source by its ID.
      *
@@ -1841,6 +3672,36 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Updates a source by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see updateSource for the plain version.
+     */
+    updateSourceWithHTTPInfo({ sourceID, sourceUpdate }, requestOptions) {
+      validateRequired("sourceID", "updateSourceWithHTTPInfo", sourceID);
+      validateRequired("sourceUpdate", "updateSourceWithHTTPInfo", sourceUpdate);
+      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.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Partially updates a task by its ID.
      *
@@ -1868,6 +3729,36 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Partially updates a task by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     * @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.
+     * @see updateTask for the plain version.
+     */
+    updateTaskWithHTTPInfo({ taskID, taskUpdate }, requestOptions) {
+      validateRequired("taskID", "updateTaskWithHTTPInfo", taskID);
+      validateRequired("taskUpdate", "updateTaskWithHTTPInfo", taskUpdate);
+      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.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Updates a task by its ID using the v1 endpoint. Use `updateTask` instead.
      *
@@ -1897,6 +3788,38 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Updates a task by its ID using the v1 endpoint. Use `updateTask` instead.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     *
+     * @deprecated
+     * @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.
+     * @see updateTaskV1 for the plain version.
+     */
+    updateTaskV1WithHTTPInfo({ taskID, taskUpdate }, requestOptions) {
+      validateRequired("taskID", "updateTaskV1WithHTTPInfo", taskID);
+      validateRequired("taskUpdate", "updateTaskV1WithHTTPInfo", taskUpdate);
+      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.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Updates a transformation by its ID.
      *
@@ -1928,6 +3851,40 @@ function createIngestionClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Updates a transformation by its ID.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     *  - deleteIndex
+     *  - editSettings
+     * @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.
+     * @see updateTransformation for the plain version.
+     */
+    updateTransformationWithHTTPInfo({ transformationID, transformationCreate }, requestOptions) {
+      validateRequired("transformationID", "updateTransformationWithHTTPInfo", transformationID);
+      validateRequired("transformationCreate", "updateTransformationWithHTTPInfo", transformationCreate);
+      validateRequired("transformationCreate.name", "updateTransformationWithHTTPInfo", transformationCreate.name);
+      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.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Validates a source payload to ensure it can be created and that the data source can be reached by Algolia.
      *
@@ -1950,6 +3907,7 @@ function createIngestionClient({
         data: sourceCreate ? sourceCreate : {}
       };
       requestOptions = {
+        ...requestOptions,
         timeouts: {
           connect: 18e4,
           read: 18e4,
@@ -1959,6 +3917,41 @@ function createIngestionClient({
       };
       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.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see validateSource for the plain version.
+     */
+    validateSourceWithHTTPInfo(sourceCreate, requestOptions = void 0) {
+      const requestPath = "/1/sources/validate";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: sourceCreate ? sourceCreate : {}
+      };
+      requestOptions = {
+        ...requestOptions,
+        timeouts: {
+          connect: 18e4,
+          read: 18e4,
+          write: 18e4,
+          ...requestOptions == null ? void 0 : requestOptions.timeouts
+        }
+      };
+      return transporter.requestWithHttpInfo(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.
      *
@@ -1985,6 +3978,7 @@ function createIngestionClient({
         data: sourceUpdate
       };
       requestOptions = {
+        ...requestOptions,
         timeouts: {
           connect: 18e4,
           read: 18e4,
@@ -1993,6 +3987,45 @@ function createIngestionClient({
         }
       };
       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.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * 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.
+     * @see validateSourceBeforeUpdate for the plain version.
+     */
+    validateSourceBeforeUpdateWithHTTPInfo({ sourceID, sourceUpdate }, requestOptions) {
+      validateRequired("sourceID", "validateSourceBeforeUpdateWithHTTPInfo", sourceID);
+      validateRequired("sourceUpdate", "validateSourceBeforeUpdateWithHTTPInfo", sourceUpdate);
+      const requestPath = "/1/sources/{sourceID}/validate".replace("{sourceID}", encodeURIComponent(sourceID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: sourceUpdate
+      };
+      requestOptions = {
+        ...requestOptions,
+        timeouts: {
+          connect: 18e4,
+          read: 18e4,
+          write: 18e4,
+          ...requestOptions == null ? void 0 : requestOptions.timeouts
+        }
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
     }
   };
 }