@algolia/ingestion 1.0.0-alpha.7 → 1.0.0-alpha.71

package/dist/ingestion.esm.node.js

@@ -1,826 +1,1210 @@
 import { createAuth, createTransporter, getAlgoliaAgent, DEFAULT_CONNECT_TIMEOUT_NODE, DEFAULT_READ_TIMEOUT_NODE, DEFAULT_WRITE_TIMEOUT_NODE, createNullCache, createMemoryCache } from '@algolia/client-common';
 import { createHttpRequester } from '@algolia/requester-node-http';
 
-// This file is generated, manual changes will be lost - read more on https://github.com/algolia/api-clients-automation.
-const apiClientVersion = '1.0.0-alpha.7';
-const REGIONS = ['us'];
-function getDefaultHosts(region) {
-    const url = 'data.{region}.algolia.com'.replace('{region}', region);
-    return [{ url, accept: 'readWrite', protocol: 'https' }];
-}
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function createIngestionClient({ appId: appIdOption, apiKey: apiKeyOption, authMode, algoliaAgents, region: regionOption, ...options }) {
-    const auth = createAuth(appIdOption, apiKeyOption, authMode);
-    const transporter = createTransporter({
-        hosts: getDefaultHosts(regionOption),
-        ...options,
-        algoliaAgent: {
-            ...getAlgoliaAgent({
-                algoliaAgents,
-                client: 'Ingestion',
-                version: apiClientVersion,
-            }),
-            value: '',
-        },
-        baseHeaders: {
-            'content-type': 'text/plain',
-            ...auth.headers(),
-            ...options.baseHeaders,
-        },
-        baseQueryParameters: {
-            ...auth.queryParameters(),
-            ...options.baseQueryParameters,
-        },
-    });
-    return {
-        transporter,
-        /**
-         * The `appId` currently in use.
-         */
-        appId: appIdOption,
-        /**
-         * Clears the cache of the transporter for the `requestsCache` and `responsesCache` properties.
-         */
-        clearCache() {
-            return Promise.all([
-                transporter.requestsCache.clear(),
-                transporter.responsesCache.clear(),
-            ]).then(() => undefined);
-        },
-        /**
-         * Get the value of the `algoliaAgent`, used by our libraries internally and telemetry system.
-         */
-        get _ua() {
-            return transporter.algoliaAgent.value;
-        },
-        /**
-         * Adds a `segment` to the `x-algolia-agent` sent with every requests.
-         *
-         * @param segment - The algolia agent (user-agent) segment to add.
-         * @param version - The version of the agent.
-         */
-        addAlgoliaAgent(segment, version) {
-            transporter.algoliaAgent.add({ segment, version });
-        },
-        /**
-         * Create a authentication.
-         *
-         * @summary Create a authentication.
-         * @param authenticationCreate -.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createAuthentication(authenticationCreate, requestOptions) {
-            if (!authenticationCreate) {
-                throw new Error('Parameter `authenticationCreate` is required when calling `createAuthentication`.');
-            }
-            const requestPath = '/1/authentications';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: authenticationCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Create a destination.
-         *
-         * @summary Create a destination.
-         * @param destinationCreate -.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createDestination(destinationCreate, requestOptions) {
-            if (!destinationCreate) {
-                throw new Error('Parameter `destinationCreate` is required when calling `createDestination`.');
-            }
-            const requestPath = '/1/destinations';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: destinationCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Create a source.
-         *
-         * @summary Create a source.
-         * @param sourceCreate -.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createSource(sourceCreate, requestOptions) {
-            if (!sourceCreate) {
-                throw new Error('Parameter `sourceCreate` is required when calling `createSource`.');
-            }
-            const requestPath = '/1/sources';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: sourceCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Create a task.
-         *
-         * @summary Create a task.
-         * @param taskCreate -.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createTask(taskCreate, requestOptions) {
-            if (!taskCreate) {
-                throw new Error('Parameter `taskCreate` is required when calling `createTask`.');
-            }
-            if (!taskCreate.sourceID) {
-                throw new Error('Parameter `taskCreate.sourceID` is required when calling `createTask`.');
-            }
-            if (!taskCreate.action) {
-                throw new Error('Parameter `taskCreate.action` is required when calling `createTask`.');
-            }
-            const requestPath = '/1/tasks';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: taskCreate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Soft delete a authentication.
-         *
-         * @summary Delete a authentication.
-         * @param deleteAuthentication - The deleteAuthentication object.
-         * @param deleteAuthentication.authenticationID - The authentication uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteAuthentication({ authenticationID }, requestOptions) {
-            if (!authenticationID) {
-                throw new Error('Parameter `authenticationID` is required when calling `deleteAuthentication`.');
-            }
-            const requestPath = '/1/authentications/{authenticationID}'.replace('{authenticationID}', encodeURIComponent(authenticationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Soft delete a destination.
-         *
-         * @summary Delete a destination.
-         * @param deleteDestination - The deleteDestination object.
-         * @param deleteDestination.destinationID - The destination uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteDestination({ destinationID }, requestOptions) {
-            if (!destinationID) {
-                throw new Error('Parameter `destinationID` is required when calling `deleteDestination`.');
-            }
-            const requestPath = '/1/destinations/{destinationID}'.replace('{destinationID}', encodeURIComponent(destinationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Soft delete a source.
-         *
-         * @summary Delete a source.
-         * @param deleteSource - The deleteSource object.
-         * @param deleteSource.sourceID - The source uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteSource({ sourceID }, requestOptions) {
-            if (!sourceID) {
-                throw new Error('Parameter `sourceID` is required when calling `deleteSource`.');
-            }
-            const requestPath = '/1/sources/{sourceID}'.replace('{sourceID}', encodeURIComponent(sourceID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Soft delete a task.
-         *
-         * @summary Delete a task.
-         * @param deleteTask - The deleteTask object.
-         * @param deleteTask.taskID - The task uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteTask({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `deleteTask`.');
-            }
-            const requestPath = '/1/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Disable a task.
-         *
-         * @summary Disable a task.
-         * @param disableTask - The disableTask object.
-         * @param disableTask.taskID - The task uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        disableTask({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `disableTask`.');
-            }
-            const requestPath = '/1/tasks/{taskID}/disable'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Enable a task.
-         *
-         * @summary Enable a task.
-         * @param enableTask - The enableTask object.
-         * @param enableTask.taskID - The task uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        enableTask({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `enableTask`.');
-            }
-            const requestPath = '/1/tasks/{taskID}/enable'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a authentication.
-         *
-         * @summary Get a authentication.
-         * @param getAuthentication - The getAuthentication object.
-         * @param getAuthentication.authenticationID - The authentication uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getAuthentication({ authenticationID }, requestOptions) {
-            if (!authenticationID) {
-                throw new Error('Parameter `authenticationID` is required when calling `getAuthentication`.');
-            }
-            const requestPath = '/1/authentications/{authenticationID}'.replace('{authenticationID}', encodeURIComponent(authenticationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a list of authentications.
-         *
-         * @summary Get a list of authentications.
-         * @param getAuthentications - The getAuthentications object.
-         * @param getAuthentications.itemsPerPage - The number of items per page to return.
-         * @param getAuthentications.page - The page number to fetch, starting at 1.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getAuthentications({ itemsPerPage, page } = {}, requestOptions = undefined) {
-            const requestPath = '/1/authentications';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a destination.
-         *
-         * @summary Get a destination.
-         * @param getDestination - The getDestination object.
-         * @param getDestination.destinationID - The destination uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getDestination({ destinationID }, requestOptions) {
-            if (!destinationID) {
-                throw new Error('Parameter `destinationID` is required when calling `getDestination`.');
-            }
-            const requestPath = '/1/destinations/{destinationID}'.replace('{destinationID}', encodeURIComponent(destinationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a list of destinations.
-         *
-         * @summary Get a list of destinations.
-         * @param getDestinations - The getDestinations object.
-         * @param getDestinations.itemsPerPage - The number of items per page to return.
-         * @param getDestinations.page - The page number to fetch, starting at 1.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getDestinations({ itemsPerPage, page } = {}, requestOptions = undefined) {
-            const requestPath = '/1/destinations';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get an event in a specific run.
-         *
-         * @summary Get an event in a specific run.
-         * @param getEvent - The getEvent object.
-         * @param getEvent.runID - The run uuid.
-         * @param getEvent.eventID - The event uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getEvent({ runID, eventID }, requestOptions) {
-            if (!runID) {
-                throw new Error('Parameter `runID` is required when calling `getEvent`.');
-            }
-            if (!eventID) {
-                throw new Error('Parameter `eventID` is required when calling `getEvent`.');
-            }
-            const requestPath = '/1/runs/{runID}/events/{eventID}'
-                .replace('{runID}', encodeURIComponent(runID))
-                .replace('{eventID}', encodeURIComponent(eventID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a list of events for a specific run.
-         *
-         * @summary Get a list of events for a specific run.
-         * @param getEvents - The getEvents object.
-         * @param getEvents.runID - The run uuid.
-         * @param getEvents.itemsPerPage - The number of items per page to return.
-         * @param getEvents.page - The page number to fetch, starting at 1.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getEvents({ runID, itemsPerPage, page }, requestOptions) {
-            if (!runID) {
-                throw new Error('Parameter `runID` is required when calling `getEvents`.');
-            }
-            const requestPath = '/1/runs/{runID}/events'.replace('{runID}', encodeURIComponent(runID));
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a run.
-         *
-         * @summary Get a run.
-         * @param getRun - The getRun object.
-         * @param getRun.runID - The run uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getRun({ runID }, requestOptions) {
-            if (!runID) {
-                throw new Error('Parameter `runID` is required when calling `getRun`.');
-            }
-            const requestPath = '/1/runs/{runID}'.replace('{runID}', encodeURIComponent(runID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a list of runs.
-         *
-         * @summary Get a list of runs.
-         * @param getRuns - The getRuns object.
-         * @param getRuns.itemsPerPage - The number of items per page to return.
-         * @param getRuns.page - The page number to fetch, starting at 1.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getRuns({ itemsPerPage, page } = {}, requestOptions = undefined) {
-            const requestPath = '/1/runs';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a list of runs associated with a taskID.
-         *
-         * @summary Get a list of runs associated with a taskID.
-         * @param getRunsByTaskID - The getRunsByTaskID object.
-         * @param getRunsByTaskID.taskID - The task uuid.
-         * @param getRunsByTaskID.itemsPerPage - The number of items per page to return.
-         * @param getRunsByTaskID.page - The page number to fetch, starting at 1.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getRunsByTaskID({ taskID, itemsPerPage, page }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `getRunsByTaskID`.');
-            }
-            const requestPath = '/1/runs/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a source.
-         *
-         * @summary Get a source.
-         * @param getSource - The getSource object.
-         * @param getSource.sourceID - The source uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getSource({ sourceID }, requestOptions) {
-            if (!sourceID) {
-                throw new Error('Parameter `sourceID` is required when calling `getSource`.');
-            }
-            const requestPath = '/1/sources/{sourceID}'.replace('{sourceID}', encodeURIComponent(sourceID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a list of sources.
-         *
-         * @summary Get a list of sources.
-         * @param getSources - The getSources object.
-         * @param getSources.itemsPerPage - The number of items per page to return.
-         * @param getSources.page - The page number to fetch, starting at 1.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getSources({ itemsPerPage, page } = {}, requestOptions = undefined) {
-            const requestPath = '/1/sources';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a task.
-         *
-         * @summary Get a task.
-         * @param getTask - The getTask object.
-         * @param getTask.taskID - The task uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getTask({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `getTask`.');
-            }
-            const requestPath = '/1/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get a list of tasks.
-         *
-         * @summary Get a list of tasks.
-         * @param getTasks - The getTasks object.
-         * @param getTasks.itemsPerPage - The number of items per page to return.
-         * @param getTasks.page - The page number to fetch, starting at 1.
-         * @param getTasks.action - Which action the returned task should have. Can be a list of string separated with commas.
-         * @param getTasks.enabled - If the returned task should have its \'enabled\' property set to true.
-         * @param getTasks.destinationID - Which destinationID the returned task should have. Can be a list of string separated with commas.
-         * @param getTasks.triggerType - Which trigger type the returned task should have. Can be a list of string separated with commas.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getTasks({ itemsPerPage, page, action, enabled, destinationID, triggerType, } = {}, requestOptions = undefined) {
-            const requestPath = '/1/tasks';
-            const headers = {};
-            const queryParameters = {};
-            if (itemsPerPage !== undefined) {
-                queryParameters.itemsPerPage = itemsPerPage.toString();
-            }
-            if (page !== undefined) {
-                queryParameters.page = page.toString();
-            }
-            if (action !== undefined) {
-                queryParameters.action = action.toString();
-            }
-            if (enabled !== undefined) {
-                queryParameters.enabled = enabled.toString();
-            }
-            if (destinationID !== undefined) {
-                queryParameters.destinationID = destinationID.toString();
-            }
-            if (triggerType !== undefined) {
-                queryParameters.triggerType = triggerType.toString();
-            }
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Run a task.
-         *
-         * @summary Run a task.
-         * @param runTask - The runTask object.
-         * @param runTask.taskID - The task uuid.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        runTask({ taskID }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `runTask`.');
-            }
-            const requestPath = '/1/tasks/{taskID}/run'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Update a authentication.
-         *
-         * @summary Update a authentication.
-         * @param updateAuthentication - The updateAuthentication object.
-         * @param updateAuthentication.authenticationID - The authentication uuid.
-         * @param updateAuthentication.authenticationUpdate - The authenticationUpdate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateAuthentication({ authenticationID, authenticationUpdate }, requestOptions) {
-            if (!authenticationID) {
-                throw new Error('Parameter `authenticationID` is required when calling `updateAuthentication`.');
-            }
-            if (!authenticationUpdate) {
-                throw new Error('Parameter `authenticationUpdate` is required when calling `updateAuthentication`.');
-            }
-            const requestPath = '/1/authentications/{authenticationID}'.replace('{authenticationID}', encodeURIComponent(authenticationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PUT',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: authenticationUpdate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Update a destination.
-         *
-         * @summary Update a destination.
-         * @param updateDestination - The updateDestination object.
-         * @param updateDestination.destinationID - The destination uuid.
-         * @param updateDestination.destinationUpdate - The destinationUpdate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateDestination({ destinationID, destinationUpdate }, requestOptions) {
-            if (!destinationID) {
-                throw new Error('Parameter `destinationID` is required when calling `updateDestination`.');
-            }
-            if (!destinationUpdate) {
-                throw new Error('Parameter `destinationUpdate` is required when calling `updateDestination`.');
-            }
-            const requestPath = '/1/destinations/{destinationID}'.replace('{destinationID}', encodeURIComponent(destinationID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PUT',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: destinationUpdate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Update a source.
-         *
-         * @summary Update a source.
-         * @param updateSource - The updateSource object.
-         * @param updateSource.sourceID - The source uuid.
-         * @param updateSource.sourceUpdate - The sourceUpdate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateSource({ sourceID, sourceUpdate }, requestOptions) {
-            if (!sourceID) {
-                throw new Error('Parameter `sourceID` is required when calling `updateSource`.');
-            }
-            if (!sourceUpdate) {
-                throw new Error('Parameter `sourceUpdate` is required when calling `updateSource`.');
-            }
-            const requestPath = '/1/sources/{sourceID}'.replace('{sourceID}', encodeURIComponent(sourceID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: sourceUpdate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Update a task.
-         *
-         * @summary Update a task.
-         * @param updateTask - The updateTask object.
-         * @param updateTask.taskID - The task uuid.
-         * @param updateTask.taskUpdate - The taskUpdate object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateTask({ taskID, taskUpdate }, requestOptions) {
-            if (!taskID) {
-                throw new Error('Parameter `taskID` is required when calling `updateTask`.');
-            }
-            if (!taskUpdate) {
-                throw new Error('Parameter `taskUpdate` is required when calling `updateTask`.');
-            }
-            const requestPath = '/1/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PUT',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: taskUpdate,
-            };
-            return transporter.request(request, requestOptions);
-        },
-    };
+// Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
+const apiClientVersion = '1.0.0-alpha.71';
+const REGIONS = ['eu', 'us'];
+function getDefaultHosts(region) {
+    const url = 'data.{region}.algolia.com'.replace('{region}', region);
+    return [{ url, accept: 'readWrite', protocol: 'https' }];
+}
+/**
+ * Guard: Return strongly typed specific OnDemandTrigger for a given Trigger.
+ *
+ * @summary Guard method that returns a strongly typed specific OnDemandTrigger for a given Trigger.
+ * @param trigger - The given Task Trigger.
+ */
+function isOnDemandTrigger(trigger) {
+    return trigger.type === 'onDemand';
+}
+/**
+ * Guard: Return strongly typed specific ScheduleTrigger for a given Trigger.
+ *
+ * @summary Guard method that returns a strongly typed specific ScheduleTrigger for a given Trigger.
+ * @param trigger - The given Task Trigger.
+ */
+function isScheduleTrigger(trigger) {
+    return trigger.type === 'schedule';
+}
+/**
+ * Guard: Return strongly typed specific SubscriptionTrigger for a given Trigger.
+ *
+ * @summary Guard method that returns a strongly typed specific SubscriptionTrigger for a given Trigger.
+ * @param trigger - The given Task Trigger.
+ */
+function isSubscriptionTrigger(trigger) {
+    return trigger.type === 'subscription';
+}
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function createIngestionClient({ appId: appIdOption, apiKey: apiKeyOption, authMode, algoliaAgents, region: regionOption, ...options }) {
+    const auth = createAuth(appIdOption, apiKeyOption, authMode);
+    const transporter = createTransporter({
+        hosts: getDefaultHosts(regionOption),
+        ...options,
+        algoliaAgent: getAlgoliaAgent({
+            algoliaAgents,
+            client: 'Ingestion',
+            version: apiClientVersion,
+        }),
+        baseHeaders: {
+            'content-type': 'text/plain',
+            ...auth.headers(),
+            ...options.baseHeaders,
+        },
+        baseQueryParameters: {
+            ...auth.queryParameters(),
+            ...options.baseQueryParameters,
+        },
+    });
+    return {
+        transporter,
+        /**
+         * The `appId` currently in use.
+         */
+        appId: appIdOption,
+        /**
+         * Clears the cache of the transporter for the `requestsCache` and `responsesCache` properties.
+         */
+        clearCache() {
+            return Promise.all([
+                transporter.requestsCache.clear(),
+                transporter.responsesCache.clear(),
+            ]).then(() => undefined);
+        },
+        /**
+         * Get the value of the `algoliaAgent`, used by our libraries internally and telemetry system.
+         */
+        get _ua() {
+            return transporter.algoliaAgent.value;
+        },
+        /**
+         * Adds a `segment` to the `x-algolia-agent` sent with every requests.
+         *
+         * @param segment - The algolia agent (user-agent) segment to add.
+         * @param version - The version of the agent.
+         */
+        addAlgoliaAgent(segment, version) {
+            transporter.algoliaAgent.add({ segment, version });
+        },
+        /**
+         * Create a authentication.
+         *
+         * @summary Create a authentication.
+         * @param authenticationCreate -.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        createAuthentication(authenticationCreate, requestOptions) {
+            if (!authenticationCreate) {
+                throw new Error('Parameter `authenticationCreate` is required when calling `createAuthentication`.');
+            }
+            if (!authenticationCreate.type) {
+                throw new Error('Parameter `authenticationCreate.type` is required when calling `createAuthentication`.');
+            }
+            if (!authenticationCreate.name) {
+                throw new Error('Parameter `authenticationCreate.name` is required when calling `createAuthentication`.');
+            }
+            if (!authenticationCreate.input) {
+                throw new Error('Parameter `authenticationCreate.input` is required when calling `createAuthentication`.');
+            }
+            const requestPath = '/1/authentications';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: authenticationCreate,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Create a destination.
+         *
+         * @summary Create a destination.
+         * @param destinationCreate -.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        createDestination(destinationCreate, requestOptions) {
+            if (!destinationCreate) {
+                throw new Error('Parameter `destinationCreate` is required when calling `createDestination`.');
+            }
+            if (!destinationCreate.type) {
+                throw new Error('Parameter `destinationCreate.type` is required when calling `createDestination`.');
+            }
+            if (!destinationCreate.name) {
+                throw new Error('Parameter `destinationCreate.name` is required when calling `createDestination`.');
+            }
+            if (!destinationCreate.input) {
+                throw new Error('Parameter `destinationCreate.input` is required when calling `createDestination`.');
+            }
+            const requestPath = '/1/destinations';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: destinationCreate,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Create a source.
+         *
+         * @summary Create a source.
+         * @param sourceCreate -.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        createSource(sourceCreate, requestOptions) {
+            if (!sourceCreate) {
+                throw new Error('Parameter `sourceCreate` is required when calling `createSource`.');
+            }
+            if (!sourceCreate.type) {
+                throw new Error('Parameter `sourceCreate.type` is required when calling `createSource`.');
+            }
+            if (!sourceCreate.name) {
+                throw new Error('Parameter `sourceCreate.name` is required when calling `createSource`.');
+            }
+            if (!sourceCreate.input) {
+                throw new Error('Parameter `sourceCreate.input` is required when calling `createSource`.');
+            }
+            const requestPath = '/1/sources';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: sourceCreate,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Create a task.
+         *
+         * @summary Create a task.
+         * @param taskCreate -.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        createTask(taskCreate, requestOptions) {
+            if (!taskCreate) {
+                throw new Error('Parameter `taskCreate` is required when calling `createTask`.');
+            }
+            if (!taskCreate.sourceID) {
+                throw new Error('Parameter `taskCreate.sourceID` is required when calling `createTask`.');
+            }
+            if (!taskCreate.destinationID) {
+                throw new Error('Parameter `taskCreate.destinationID` is required when calling `createTask`.');
+            }
+            if (!taskCreate.trigger) {
+                throw new Error('Parameter `taskCreate.trigger` is required when calling `createTask`.');
+            }
+            if (!taskCreate.action) {
+                throw new Error('Parameter `taskCreate.action` is required when calling `createTask`.');
+            }
+            const requestPath = '/1/tasks';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: taskCreate,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * This method allow you to send requests to the Algolia REST API.
+         *
+         * @summary Send requests to the Algolia REST API.
+         * @param customDelete - The customDelete object.
+         * @param customDelete.path - Path of the endpoint, anything after \"/1\" must be specified.
+         * @param customDelete.parameters - Query parameters to apply to the current query.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        customDelete({ path, parameters }, requestOptions) {
+            if (!path) {
+                throw new Error('Parameter `path` is required when calling `customDelete`.');
+            }
+            const requestPath = '/1{path}'.replace('{path}', path);
+            const headers = {};
+            const queryParameters = parameters ? parameters : {};
+            const request = {
+                method: 'DELETE',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * This method allow you to send requests to the Algolia REST API.
+         *
+         * @summary Send requests to the Algolia REST API.
+         * @param customGet - The customGet object.
+         * @param customGet.path - Path of the endpoint, anything after \"/1\" must be specified.
+         * @param customGet.parameters - Query parameters to apply to the current query.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        customGet({ path, parameters }, requestOptions) {
+            if (!path) {
+                throw new Error('Parameter `path` is required when calling `customGet`.');
+            }
+            const requestPath = '/1{path}'.replace('{path}', path);
+            const headers = {};
+            const queryParameters = parameters ? parameters : {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * This method allow you to send requests to the Algolia REST API.
+         *
+         * @summary Send requests to the Algolia REST API.
+         * @param customPost - The customPost object.
+         * @param customPost.path - Path of the endpoint, anything after \"/1\" must be specified.
+         * @param customPost.parameters - Query parameters to apply to the current query.
+         * @param customPost.body - Parameters to send with the custom request.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        customPost({ path, parameters, body }, requestOptions) {
+            if (!path) {
+                throw new Error('Parameter `path` is required when calling `customPost`.');
+            }
+            const requestPath = '/1{path}'.replace('{path}', path);
+            const headers = {};
+            const queryParameters = parameters ? parameters : {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: body ? body : {},
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * This method allow you to send requests to the Algolia REST API.
+         *
+         * @summary Send requests to the Algolia REST API.
+         * @param customPut - The customPut object.
+         * @param customPut.path - Path of the endpoint, anything after \"/1\" must be specified.
+         * @param customPut.parameters - Query parameters to apply to the current query.
+         * @param customPut.body - Parameters to send with the custom request.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        customPut({ path, parameters, body }, requestOptions) {
+            if (!path) {
+                throw new Error('Parameter `path` is required when calling `customPut`.');
+            }
+            const requestPath = '/1{path}'.replace('{path}', path);
+            const headers = {};
+            const queryParameters = parameters ? parameters : {};
+            const request = {
+                method: 'PUT',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: body ? body : {},
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Soft delete the authentication of the given authenticationID.
+         *
+         * @summary Delete a authentication.
+         * @param deleteAuthentication - The deleteAuthentication object.
+         * @param deleteAuthentication.authenticationID - The authentication UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        deleteAuthentication({ authenticationID }, requestOptions) {
+            if (!authenticationID) {
+                throw new Error('Parameter `authenticationID` is required when calling `deleteAuthentication`.');
+            }
+            const requestPath = '/1/authentications/{authenticationID}'.replace('{authenticationID}', encodeURIComponent(authenticationID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'DELETE',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Soft delete the destination of the given destinationID.
+         *
+         * @summary Delete a destination.
+         * @param deleteDestination - The deleteDestination object.
+         * @param deleteDestination.destinationID - The destination UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        deleteDestination({ destinationID }, requestOptions) {
+            if (!destinationID) {
+                throw new Error('Parameter `destinationID` is required when calling `deleteDestination`.');
+            }
+            const requestPath = '/1/destinations/{destinationID}'.replace('{destinationID}', encodeURIComponent(destinationID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'DELETE',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Soft delete the source of the given sourceID.
+         *
+         * @summary Delete a source.
+         * @param deleteSource - The deleteSource object.
+         * @param deleteSource.sourceID - The source UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        deleteSource({ sourceID }, requestOptions) {
+            if (!sourceID) {
+                throw new Error('Parameter `sourceID` is required when calling `deleteSource`.');
+            }
+            const requestPath = '/1/sources/{sourceID}'.replace('{sourceID}', encodeURIComponent(sourceID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'DELETE',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Soft delete the task of the given taskID.
+         *
+         * @summary Delete a task.
+         * @param deleteTask - The deleteTask object.
+         * @param deleteTask.taskID - The task UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        deleteTask({ taskID }, requestOptions) {
+            if (!taskID) {
+                throw new Error('Parameter `taskID` is required when calling `deleteTask`.');
+            }
+            const requestPath = '/1/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'DELETE',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Disable the task of the given taskID.
+         *
+         * @summary Disable a task.
+         * @param disableTask - The disableTask object.
+         * @param disableTask.taskID - The task UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        disableTask({ taskID }, requestOptions) {
+            if (!taskID) {
+                throw new Error('Parameter `taskID` is required when calling `disableTask`.');
+            }
+            const requestPath = '/1/tasks/{taskID}/disable'.replace('{taskID}', encodeURIComponent(taskID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'PUT',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Enable the task of the given taskID.
+         *
+         * @summary Enable a task.
+         * @param enableTask - The enableTask object.
+         * @param enableTask.taskID - The task UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        enableTask({ taskID }, requestOptions) {
+            if (!taskID) {
+                throw new Error('Parameter `taskID` is required when calling `enableTask`.');
+            }
+            const requestPath = '/1/tasks/{taskID}/enable'.replace('{taskID}', encodeURIComponent(taskID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'PUT',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get the authentication of the given authenticationID.
+         *
+         * @summary Get a authentication.
+         * @param getAuthentication - The getAuthentication object.
+         * @param getAuthentication.authenticationID - The authentication UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getAuthentication({ authenticationID }, requestOptions) {
+            if (!authenticationID) {
+                throw new Error('Parameter `authenticationID` is required when calling `getAuthentication`.');
+            }
+            const requestPath = '/1/authentications/{authenticationID}'.replace('{authenticationID}', encodeURIComponent(authenticationID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get a list of authentications for the given query parameters, with pagination details.
+         *
+         * @summary Get a list of authentications.
+         * @param getAuthentications - The getAuthentications object.
+         * @param getAuthentications.itemsPerPage - The number of items per page to return.
+         * @param getAuthentications.page - The page number to fetch, starting at 1.
+         * @param getAuthentications.type - The type of the authentications to retrieve.
+         * @param getAuthentications.platform - The platform of the authentications to retrieve.
+         * @param getAuthentications.sort - The key by which the list should be sorted.
+         * @param getAuthentications.order - The order of the returned list.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getAuthentications({ itemsPerPage, page, type, platform, sort, order, } = {}, requestOptions = undefined) {
+            const requestPath = '/1/authentications';
+            const headers = {};
+            const queryParameters = {};
+            if (itemsPerPage !== undefined) {
+                queryParameters.itemsPerPage = itemsPerPage.toString();
+            }
+            if (page !== undefined) {
+                queryParameters.page = page.toString();
+            }
+            if (type !== undefined) {
+                queryParameters.type = type.toString();
+            }
+            if (platform !== undefined) {
+                queryParameters.platform = platform.toString();
+            }
+            if (sort !== undefined) {
+                queryParameters.sort = sort.toString();
+            }
+            if (order !== undefined) {
+                queryParameters.order = order.toString();
+            }
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get the destination of the given destinationID.
+         *
+         * @summary Get a destination.
+         * @param getDestination - The getDestination object.
+         * @param getDestination.destinationID - The destination UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getDestination({ destinationID }, requestOptions) {
+            if (!destinationID) {
+                throw new Error('Parameter `destinationID` is required when calling `getDestination`.');
+            }
+            const requestPath = '/1/destinations/{destinationID}'.replace('{destinationID}', encodeURIComponent(destinationID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get a list of destinations for the given query parameters, with pagination details.
+         *
+         * @summary Get a list of destinations.
+         * @param getDestinations - The getDestinations object.
+         * @param getDestinations.itemsPerPage - The number of items per page to return.
+         * @param getDestinations.page - The page number to fetch, starting at 1.
+         * @param getDestinations.type - The type of the destinations to retrive.
+         * @param getDestinations.authenticationID - The authenticationIDs of the destinations to retrive.
+         * @param getDestinations.sort - The key by which the list should be sorted.
+         * @param getDestinations.order - The order of the returned list.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getDestinations({ itemsPerPage, page, type, authenticationID, sort, order, } = {}, requestOptions = undefined) {
+            const requestPath = '/1/destinations';
+            const headers = {};
+            const queryParameters = {};
+            if (itemsPerPage !== undefined) {
+                queryParameters.itemsPerPage = itemsPerPage.toString();
+            }
+            if (page !== undefined) {
+                queryParameters.page = page.toString();
+            }
+            if (type !== undefined) {
+                queryParameters.type = type.toString();
+            }
+            if (authenticationID !== undefined) {
+                queryParameters.authenticationID = authenticationID.toString();
+            }
+            if (sort !== undefined) {
+                queryParameters.sort = sort.toString();
+            }
+            if (order !== undefined) {
+                queryParameters.order = order.toString();
+            }
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Retrieve a stream listing for a given Singer specification compatible docker type source ID.
+         *
+         * @summary Retrieve a stream listing.
+         * @param getDockerSourceStreams - The getDockerSourceStreams object.
+         * @param getDockerSourceStreams.sourceID - The source UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getDockerSourceStreams({ sourceID }, requestOptions) {
+            if (!sourceID) {
+                throw new Error('Parameter `sourceID` is required when calling `getDockerSourceStreams`.');
+            }
+            const requestPath = '/1/sources/{sourceID}/discover'.replace('{sourceID}', encodeURIComponent(sourceID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get a single event for a specific runID.
+         *
+         * @summary Get an event.
+         * @param getEvent - The getEvent object.
+         * @param getEvent.runID - The run UUID.
+         * @param getEvent.eventID - The event UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getEvent({ runID, eventID }, requestOptions) {
+            if (!runID) {
+                throw new Error('Parameter `runID` is required when calling `getEvent`.');
+            }
+            if (!eventID) {
+                throw new Error('Parameter `eventID` is required when calling `getEvent`.');
+            }
+            const requestPath = '/1/runs/{runID}/events/{eventID}'
+                .replace('{runID}', encodeURIComponent(runID))
+                .replace('{eventID}', encodeURIComponent(eventID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get a list of events associated to the given runID, for the given query parameters.
+         *
+         * @summary Get a list of events.
+         * @param getEvents - The getEvents object.
+         * @param getEvents.runID - The run UUID.
+         * @param getEvents.itemsPerPage - The number of items per page to return.
+         * @param getEvents.page - The page number to fetch, starting at 1.
+         * @param getEvents.status - Filter the status of the events.
+         * @param getEvents.type - Filter the type of the events.
+         * @param getEvents.sort - The key by which the list should be sorted.
+         * @param getEvents.order - The order of the returned list.
+         * @param getEvents.startDate - The start date (in RFC3339 format) of the events fetching window. Defaults to \'now\'-3 hours if omitted.
+         * @param getEvents.endDate - The end date (in RFC3339 format) of the events fetching window. Defaults to \'now\' days if omitted.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getEvents({ runID, itemsPerPage, page, status, type, sort, order, startDate, endDate, }, requestOptions) {
+            if (!runID) {
+                throw new Error('Parameter `runID` is required when calling `getEvents`.');
+            }
+            const requestPath = '/1/runs/{runID}/events'.replace('{runID}', encodeURIComponent(runID));
+            const headers = {};
+            const queryParameters = {};
+            if (itemsPerPage !== undefined) {
+                queryParameters.itemsPerPage = itemsPerPage.toString();
+            }
+            if (page !== undefined) {
+                queryParameters.page = page.toString();
+            }
+            if (status !== undefined) {
+                queryParameters.status = status.toString();
+            }
+            if (type !== undefined) {
+                queryParameters.type = type.toString();
+            }
+            if (sort !== undefined) {
+                queryParameters.sort = sort.toString();
+            }
+            if (order !== undefined) {
+                queryParameters.order = order.toString();
+            }
+            if (startDate !== undefined) {
+                queryParameters.startDate = startDate.toString();
+            }
+            if (endDate !== undefined) {
+                queryParameters.endDate = endDate.toString();
+            }
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get a single run for the given ID.
+         *
+         * @summary Get a run.
+         * @param getRun - The getRun object.
+         * @param getRun.runID - The run UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getRun({ runID }, requestOptions) {
+            if (!runID) {
+                throw new Error('Parameter `runID` is required when calling `getRun`.');
+            }
+            const requestPath = '/1/runs/{runID}'.replace('{runID}', encodeURIComponent(runID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get a list of runs for the given query parameters, with pagination details.
+         *
+         * @summary Get a list of runs.
+         * @param getRuns - The getRuns object.
+         * @param getRuns.itemsPerPage - The number of items per page to return.
+         * @param getRuns.page - The page number to fetch, starting at 1.
+         * @param getRuns.status - Filter the status of the runs.
+         * @param getRuns.taskID - Filter by taskID.
+         * @param getRuns.sort - The key by which the list should be sorted.
+         * @param getRuns.order - The order of the returned list.
+         * @param getRuns.startDate - The start date (in RFC3339 format) of the runs fetching window. Defaults to \'now\'-7 days if omitted.
+         * @param getRuns.endDate - The end date (in RFC3339 format) of the runs fetching window. Defaults to \'now\' days if omitted.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getRuns({ itemsPerPage, page, status, taskID, sort, order, startDate, endDate, } = {}, requestOptions = undefined) {
+            const requestPath = '/1/runs';
+            const headers = {};
+            const queryParameters = {};
+            if (itemsPerPage !== undefined) {
+                queryParameters.itemsPerPage = itemsPerPage.toString();
+            }
+            if (page !== undefined) {
+                queryParameters.page = page.toString();
+            }
+            if (status !== undefined) {
+                queryParameters.status = status.toString();
+            }
+            if (taskID !== undefined) {
+                queryParameters.taskID = taskID.toString();
+            }
+            if (sort !== undefined) {
+                queryParameters.sort = sort.toString();
+            }
+            if (order !== undefined) {
+                queryParameters.order = order.toString();
+            }
+            if (startDate !== undefined) {
+                queryParameters.startDate = startDate.toString();
+            }
+            if (endDate !== undefined) {
+                queryParameters.endDate = endDate.toString();
+            }
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get the source of the given sourceID.
+         *
+         * @summary Get a source.
+         * @param getSource - The getSource object.
+         * @param getSource.sourceID - The source UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getSource({ sourceID }, requestOptions) {
+            if (!sourceID) {
+                throw new Error('Parameter `sourceID` is required when calling `getSource`.');
+            }
+            const requestPath = '/1/sources/{sourceID}'.replace('{sourceID}', encodeURIComponent(sourceID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get a list of sources for the given query parameters, with pagination details.
+         *
+         * @summary Get a list of sources.
+         * @param getSources - The getSources object.
+         * @param getSources.itemsPerPage - The number of items per page to return.
+         * @param getSources.page - The page number to fetch, starting at 1.
+         * @param getSources.type - The type of the sources to retrieve.
+         * @param getSources.authenticationID - The authenticationIDs of the sources to retrieve. \'none\' returns sources that doesn\'t have an authentication.
+         * @param getSources.sort - The key by which the list should be sorted.
+         * @param getSources.order - The order of the returned list.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getSources({ itemsPerPage, page, type, authenticationID, sort, order, } = {}, requestOptions = undefined) {
+            const requestPath = '/1/sources';
+            const headers = {};
+            const queryParameters = {};
+            if (itemsPerPage !== undefined) {
+                queryParameters.itemsPerPage = itemsPerPage.toString();
+            }
+            if (page !== undefined) {
+                queryParameters.page = page.toString();
+            }
+            if (type !== undefined) {
+                queryParameters.type = type.toString();
+            }
+            if (authenticationID !== undefined) {
+                queryParameters.authenticationID = authenticationID.toString();
+            }
+            if (sort !== undefined) {
+                queryParameters.sort = sort.toString();
+            }
+            if (order !== undefined) {
+                queryParameters.order = order.toString();
+            }
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get the task of the given taskID.
+         *
+         * @summary Get a task.
+         * @param getTask - The getTask object.
+         * @param getTask.taskID - The task UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getTask({ taskID }, requestOptions) {
+            if (!taskID) {
+                throw new Error('Parameter `taskID` is required when calling `getTask`.');
+            }
+            const requestPath = '/1/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get a list of tasks for the given query parameters, with pagination details.
+         *
+         * @summary Get a list of tasks.
+         * @param getTasks - The getTasks object.
+         * @param getTasks.itemsPerPage - The number of items per page to return.
+         * @param getTasks.page - The page number to fetch, starting at 1.
+         * @param getTasks.action - The action of the tasks to retrieve.
+         * @param getTasks.enabled - Whether the task is enabled or not.
+         * @param getTasks.sourceID - The sourceIDs of the tasks to retrive.
+         * @param getTasks.destinationID - The destinationIDs of the tasks to retrive.
+         * @param getTasks.triggerType - The trigger type of the task.
+         * @param getTasks.sort - The key by which the list should be sorted.
+         * @param getTasks.order - The order of the returned list.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getTasks({ itemsPerPage, page, action, enabled, sourceID, destinationID, triggerType, sort, order, } = {}, requestOptions = undefined) {
+            const requestPath = '/1/tasks';
+            const headers = {};
+            const queryParameters = {};
+            if (itemsPerPage !== undefined) {
+                queryParameters.itemsPerPage = itemsPerPage.toString();
+            }
+            if (page !== undefined) {
+                queryParameters.page = page.toString();
+            }
+            if (action !== undefined) {
+                queryParameters.action = action.toString();
+            }
+            if (enabled !== undefined) {
+                queryParameters.enabled = enabled.toString();
+            }
+            if (sourceID !== undefined) {
+                queryParameters.sourceID = sourceID.toString();
+            }
+            if (destinationID !== undefined) {
+                queryParameters.destinationID = destinationID.toString();
+            }
+            if (triggerType !== undefined) {
+                queryParameters.triggerType = triggerType.toString();
+            }
+            if (sort !== undefined) {
+                queryParameters.sort = sort.toString();
+            }
+            if (order !== undefined) {
+                queryParameters.order = order.toString();
+            }
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Run the task of the given taskID.
+         *
+         * @summary Run a task.
+         * @param runTask - The runTask object.
+         * @param runTask.taskID - The task UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        runTask({ taskID }, requestOptions) {
+            if (!taskID) {
+                throw new Error('Parameter `taskID` is required when calling `runTask`.');
+            }
+            const requestPath = '/1/tasks/{taskID}/run'.replace('{taskID}', encodeURIComponent(taskID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Search among authentications with a defined set of parameters.
+         *
+         * @summary Search among authentications.
+         * @param authenticationSearch - The authenticationSearch object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        searchAuthentications(authenticationSearch, requestOptions) {
+            if (!authenticationSearch) {
+                throw new Error('Parameter `authenticationSearch` is required when calling `searchAuthentications`.');
+            }
+            if (!authenticationSearch.authenticationIDs) {
+                throw new Error('Parameter `authenticationSearch.authenticationIDs` is required when calling `searchAuthentications`.');
+            }
+            const requestPath = '/1/authentications/search';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: authenticationSearch,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Search among destinations with a defined set of parameters.
+         *
+         * @summary Search among destinations.
+         * @param destinationSearch - The destinationSearch object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        searchDestinations(destinationSearch, requestOptions) {
+            if (!destinationSearch) {
+                throw new Error('Parameter `destinationSearch` is required when calling `searchDestinations`.');
+            }
+            if (!destinationSearch.destinationIDs) {
+                throw new Error('Parameter `destinationSearch.destinationIDs` is required when calling `searchDestinations`.');
+            }
+            const requestPath = '/1/destinations/search';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: destinationSearch,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Search among sources with a defined set of parameters.
+         *
+         * @summary Search among sources.
+         * @param sourceSearch - The sourceSearch object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        searchSources(sourceSearch, requestOptions) {
+            if (!sourceSearch) {
+                throw new Error('Parameter `sourceSearch` is required when calling `searchSources`.');
+            }
+            if (!sourceSearch.sourceIDs) {
+                throw new Error('Parameter `sourceSearch.sourceIDs` is required when calling `searchSources`.');
+            }
+            const requestPath = '/1/sources/search';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: sourceSearch,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Search among tasks with a defined set of parameters.
+         *
+         * @summary Search among tasks.
+         * @param taskSearch - The taskSearch object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        searchTasks(taskSearch, requestOptions) {
+            if (!taskSearch) {
+                throw new Error('Parameter `taskSearch` is required when calling `searchTasks`.');
+            }
+            if (!taskSearch.taskIDs) {
+                throw new Error('Parameter `taskSearch.taskIDs` is required when calling `searchTasks`.');
+            }
+            const requestPath = '/1/tasks/search';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: taskSearch,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Trigger a stream listing request for a Singer specification compatible docker type source.
+         *
+         * @summary Trigger a stream listing request.
+         * @param triggerDockerSourceDiscover - The triggerDockerSourceDiscover object.
+         * @param triggerDockerSourceDiscover.sourceID - The source UUID.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        triggerDockerSourceDiscover({ sourceID }, requestOptions) {
+            if (!sourceID) {
+                throw new Error('Parameter `sourceID` is required when calling `triggerDockerSourceDiscover`.');
+            }
+            const requestPath = '/1/sources/{sourceID}/discover'.replace('{sourceID}', encodeURIComponent(sourceID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Update the authentication of the given authenticationID.
+         *
+         * @summary Update a authentication.
+         * @param updateAuthentication - The updateAuthentication object.
+         * @param updateAuthentication.authenticationID - The authentication UUID.
+         * @param updateAuthentication.authenticationUpdate - The authenticationUpdate object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        updateAuthentication({ authenticationID, authenticationUpdate }, requestOptions) {
+            if (!authenticationID) {
+                throw new Error('Parameter `authenticationID` is required when calling `updateAuthentication`.');
+            }
+            if (!authenticationUpdate) {
+                throw new Error('Parameter `authenticationUpdate` is required when calling `updateAuthentication`.');
+            }
+            const requestPath = '/1/authentications/{authenticationID}'.replace('{authenticationID}', encodeURIComponent(authenticationID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'PATCH',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: authenticationUpdate,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Update the destination of the given destinationID.
+         *
+         * @summary Update a destination.
+         * @param updateDestination - The updateDestination object.
+         * @param updateDestination.destinationID - The destination UUID.
+         * @param updateDestination.destinationUpdate - The destinationUpdate object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        updateDestination({ destinationID, destinationUpdate }, requestOptions) {
+            if (!destinationID) {
+                throw new Error('Parameter `destinationID` is required when calling `updateDestination`.');
+            }
+            if (!destinationUpdate) {
+                throw new Error('Parameter `destinationUpdate` is required when calling `updateDestination`.');
+            }
+            const requestPath = '/1/destinations/{destinationID}'.replace('{destinationID}', encodeURIComponent(destinationID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'PATCH',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: destinationUpdate,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Update the source of the given sourceID.
+         *
+         * @summary Update a source.
+         * @param updateSource - The updateSource object.
+         * @param updateSource.sourceID - The source UUID.
+         * @param updateSource.sourceUpdate - The sourceUpdate object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        updateSource({ sourceID, sourceUpdate }, requestOptions) {
+            if (!sourceID) {
+                throw new Error('Parameter `sourceID` is required when calling `updateSource`.');
+            }
+            if (!sourceUpdate) {
+                throw new Error('Parameter `sourceUpdate` is required when calling `updateSource`.');
+            }
+            const requestPath = '/1/sources/{sourceID}'.replace('{sourceID}', encodeURIComponent(sourceID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'PATCH',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: sourceUpdate,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Update the task of the given taskID.
+         *
+         * @summary Update a task.
+         * @param updateTask - The updateTask object.
+         * @param updateTask.taskID - The task UUID.
+         * @param updateTask.taskUpdate - The taskUpdate object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        updateTask({ taskID, taskUpdate }, requestOptions) {
+            if (!taskID) {
+                throw new Error('Parameter `taskID` is required when calling `updateTask`.');
+            }
+            if (!taskUpdate) {
+                throw new Error('Parameter `taskUpdate` is required when calling `updateTask`.');
+            }
+            const requestPath = '/1/tasks/{taskID}'.replace('{taskID}', encodeURIComponent(taskID));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'PATCH',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: taskUpdate,
+            };
+            return transporter.request(request, requestOptions);
+        },
+    };
 }
 
-// This file is generated, manual changes will be lost - read more on https://github.com/algolia/api-clients-automation.
-function ingestionClient(appId, apiKey, region, options) {
-    if (!appId || typeof appId !== 'string') {
-        throw new Error('`appId` is missing.');
-    }
-    if (!apiKey || typeof apiKey !== 'string') {
-        throw new Error('`apiKey` is missing.');
-    }
-    if (!region ||
-        (region && (typeof region !== 'string' || !REGIONS.includes(region)))) {
-        throw new Error(`\`region\` is required and must be one of the following: ${REGIONS.join(', ')}`);
-    }
-    return createIngestionClient({
-        appId,
-        apiKey,
-        region,
-        timeouts: {
-            connect: DEFAULT_CONNECT_TIMEOUT_NODE,
-            read: DEFAULT_READ_TIMEOUT_NODE,
-            write: DEFAULT_WRITE_TIMEOUT_NODE,
-        },
-        requester: createHttpRequester(),
-        algoliaAgents: [{ segment: 'Node.js', version: process.versions.node }],
-        responsesCache: createNullCache(),
-        requestsCache: createNullCache(),
-        hostsCache: createMemoryCache(),
-        ...options,
-    });
+// Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
+function ingestionClient(appId, apiKey, region, options) {
+    if (!appId || typeof appId !== 'string') {
+        throw new Error('`appId` is missing.');
+    }
+    if (!apiKey || typeof apiKey !== 'string') {
+        throw new Error('`apiKey` is missing.');
+    }
+    if (!region ||
+        (region && (typeof region !== 'string' || !REGIONS.includes(region)))) {
+        throw new Error(`\`region\` is required and must be one of the following: ${REGIONS.join(', ')}`);
+    }
+    return createIngestionClient({
+        appId,
+        apiKey,
+        region,
+        timeouts: {
+            connect: DEFAULT_CONNECT_TIMEOUT_NODE,
+            read: DEFAULT_READ_TIMEOUT_NODE,
+            write: DEFAULT_WRITE_TIMEOUT_NODE,
+        },
+        requester: createHttpRequester(),
+        algoliaAgents: [{ segment: 'Node.js', version: process.versions.node }],
+        responsesCache: createNullCache(),
+        requestsCache: createNullCache(),
+        hostsCache: createMemoryCache(),
+        ...options,
+    });
 }
 
-export { apiClientVersion, ingestionClient };
+export { apiClientVersion, ingestionClient, isOnDemandTrigger, isScheduleTrigger, isSubscriptionTrigger };