@kestra-io/kestra-sdk 1.0.11 → 2.0.0-develop.3fc51071.7c8bc6c3

package/dist/client.gen-Cck1nGA2.js

@@ -0,0 +1,570 @@
+import axios from "axios";
+//#region src/openapi/core/bodySerializer.gen.ts
+const serializeFormDataPair = (data, key, value) => {
+	if (typeof value === "string" || value instanceof Blob) data.append(key, value);
+	else if (value instanceof Date) data.append(key, value.toISOString());
+	else data.append(key, JSON.stringify(value));
+};
+const formDataBodySerializer = { bodySerializer: (body) => {
+	const data = new FormData();
+	Object.entries(body).forEach(([key, value]) => {
+		if (value === void 0 || value === null) return;
+		if (Array.isArray(value)) value.forEach((v) => serializeFormDataPair(data, key, v));
+		else serializeFormDataPair(data, key, value);
+	});
+	return data;
+} };
+//#endregion
+//#region src/openapi/core/params.gen.ts
+const extraPrefixes = Object.entries({
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query"
+});
+const buildKeyMap = (fields, map) => {
+	if (!map) map = /* @__PURE__ */ new Map();
+	for (const config of fields) if ("in" in config) {
+		if (config.key) map.set(config.key, {
+			in: config.in,
+			map: config.map
+		});
+	} else if ("key" in config) map.set(config.key, { map: config.map });
+	else if (config.args) buildKeyMap(config.args, map);
+	return map;
+};
+const stripEmptySlots = (params) => {
+	for (const [slot, value] of Object.entries(params)) if (value && typeof value === "object" && !Array.isArray(value) && !Object.keys(value).length) delete params[slot];
+};
+const buildClientParams = (args, fields) => {
+	const params = {
+		body: {},
+		headers: {},
+		path: {},
+		query: {}
+	};
+	const map = buildKeyMap(fields);
+	let config;
+	for (const [index, arg] of args.entries()) {
+		if (fields[index]) config = fields[index];
+		if (!config) continue;
+		if ("in" in config) if (config.key) {
+			const field = map.get(config.key);
+			const name = field.map || config.key;
+			if (field.in) params[field.in][name] = arg;
+		} else params.body = arg;
+		else for (const [key, value] of Object.entries(arg ?? {})) {
+			const field = map.get(key);
+			if (field) if (field.in) {
+				const name = field.map || key;
+				params[field.in][name] = value;
+			} else params[field.map] = value;
+			else {
+				const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
+				if (extra) {
+					const [prefix, slot] = extra;
+					params[slot][key.slice(prefix.length)] = value;
+				} else if ("allowExtra" in config && config.allowExtra) {
+					for (const [slot, allowed] of Object.entries(config.allowExtra)) if (allowed) {
+						params[slot][key] = value;
+						break;
+					}
+				}
+			}
+		}
+	}
+	stripEmptySlots(params);
+	return params;
+};
+//#endregion
+//#region src/openapi/core/serverSentEvents.gen.ts
+function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const requestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) request = await onRequest(url, requestInit);
+				const response = await (options.fetch ?? globalThis.fetch)(request);
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						buffer = buffer.replace(/\r\n?/g, "\n");
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				await sleep(Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4));
+			}
+		}
+	};
+	return { stream: createStream() };
+}
+//#endregion
+//#region src/openapi/core/pathSerializer.gen.ts
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+//#endregion
+//#region src/openapi/core/utils.gen.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+function getValidRequestBody(options) {
+	const hasBody = options.body !== void 0;
+	if (hasBody && options.bodySerializer) {
+		if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
+}
+//#endregion
+//#region src/openapi/core/auth.gen.ts
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+//#endregion
+//#region src/openapi/client/utils.gen.ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			const options = parameters[name] || args;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...options.array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...options.object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved: options.allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (name in options.headers || options.query?.[name]) return true;
+	if ("Cookie" in options.headers && options.headers["Cookie"] && typeof options.headers["Cookie"] === "string") return options.headers["Cookie"].includes(`${name}=`);
+	return false;
+};
+const setAuthParams = async ({ security, ...options }) => {
+	for (const auth of security) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie": {
+				const value = `${name}=${token}`;
+				if ("Cookie" in options.headers && options.headers["Cookie"]) options.headers["Cookie"] = `${options.headers["Cookie"]}; ${value}`;
+				else options.headers["Cookie"] = value;
+				break;
+			}
+			default:
+				options.headers[name] = token;
+				break;
+		}
+	}
+};
+const buildUrl = (options) => {
+	const instanceBaseUrl = options.axios?.defaults?.baseURL;
+	return getUrl({
+		baseUrl: options.baseURL && typeof options.baseURL === "string" ? options.baseURL : instanceBaseUrl,
+		path: options.path,
+		query: !options.paramsSerializer ? options.query : void 0,
+		querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+		url: options.url
+	});
+};
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+/**
+* Special Axios headers keywords allowing to set headers by request method.
+*/
+const axiosHeadersKeywords = [
+	"common",
+	"delete",
+	"get",
+	"head",
+	"patch",
+	"post",
+	"put"
+];
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = {};
+	for (const header of headers) {
+		if (!header || typeof header !== "object") continue;
+		const iterator = Object.entries(header);
+		for (const [key, value] of iterator) if (axiosHeadersKeywords.includes(key) && typeof value === "object") mergedHeaders[key] = {
+			...mergedHeaders[key],
+			...value
+		};
+		else if (value === null) delete mergedHeaders[key];
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders[key] = [...mergedHeaders[key] ?? [], v];
+		else if (value !== void 0) mergedHeaders[key] = typeof value === "object" ? JSON.stringify(value) : value;
+	}
+	return mergedHeaders;
+};
+const createConfig = (override = {}) => ({ ...override });
+//#endregion
+//#region src/openapi/client/client.gen.ts
+const createClient = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	let instance;
+	if (_config.axios && !("Axios" in _config.axios)) instance = _config.axios;
+	else {
+		const { auth, ...configWithoutAuth } = _config;
+		instance = axios.create(configWithoutAuth);
+	}
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		instance.defaults = {
+			...instance.defaults,
+			..._config,
+			headers: mergeHeaders(instance.defaults.headers, _config.headers)
+		};
+		return getConfig();
+	};
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			axios: options.axios ?? _config.axios ?? instance,
+			headers: mergeHeaders(_config.headers, options.headers)
+		};
+		if (opts.security) await setAuthParams({
+			...opts,
+			security: opts.security
+		});
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body !== void 0 && opts.bodySerializer) opts.body = opts.bodySerializer(opts.body);
+		return {
+			opts,
+			url: buildUrl(opts)
+		};
+	};
+	const request = async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		try {
+			const _axios = opts.axios;
+			const { auth, ...optsWithoutAuth } = opts;
+			const response = await _axios({
+				...optsWithoutAuth,
+				baseURL: "",
+				data: getValidRequestBody(opts),
+				headers: opts.headers,
+				params: opts.paramsSerializer ? opts.query : void 0,
+				url
+			});
+			let { data } = response;
+			if (opts.responseType === "json") {
+				if (opts.responseValidator) await opts.responseValidator(data);
+				if (opts.responseTransformer) data = await opts.responseTransformer(data);
+			}
+			return {
+				...response,
+				data: data ?? {}
+			};
+		} catch (error) {
+			const e = error;
+			if (opts.throwOnError) throw e;
+			e.error = e.response?.data ?? {};
+			return e;
+		}
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			headers: opts.headers,
+			method,
+			serializedBody: getValidRequestBody(opts),
+			signal: opts.signal,
+			url
+		});
+	};
+	const _buildUrl = (options) => buildUrl({
+		axios: instance,
+		..._config,
+		...options
+	});
+	return {
+		buildUrl: _buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		instance,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE")
+		},
+		trace: makeMethodFn("TRACE")
+	};
+};
+//#endregion
+//#region src/openapi/client.gen.ts
+const client = createClient(createConfig({ throwOnError: true }));
+//#endregion
+export { buildClientParams as n, formDataBodySerializer as r, client as t };

package/dist/client.js

@@ -0,0 +1,2 @@
+import { t as client } from "./client.gen-Cck1nGA2.js";
+export { client };

package/dist/cluster.d.ts

@@ -0,0 +1,2 @@
+import { n as exitMaintenance, t as enterMaintenance } from "./ks-Cluster.gen-dtsebDgv.js";
+export { enterMaintenance, exitMaintenance };

package/dist/cluster.js

@@ -0,0 +1,7 @@
+import { Yr as _0F86A2E5, di as _1A1Ca315 } from "./sdk.gen-N-hcF-we.js";
+import { getDataOrThrow } from "./shared.js";
+//#region src/openapi/sdk/ks-Cluster.gen.ts
+const enterMaintenance = (options) => getDataOrThrow(_0F86A2E5(options));
+const exitMaintenance = (options) => getDataOrThrow(_1A1Ca315(options));
+//#endregion
+export { enterMaintenance, exitMaintenance };

package/dist/dashboards.d.ts

@@ -0,0 +1,2 @@
+import { Ba as exportChartToCsv, Fa as createDashboard, Ga as validateChart, Ha as previewChart, Ia as dashboard, Ka as validateDashboard, La as dashboardChartData, Ra as defaultDashboards_1, Ua as searchDashboards, Va as exportDashboardChartDataToCSV, Wa as updateDashboard, za as deleteDashboard } from "./index-CpGCUULo.js";
+export { createDashboard, dashboard, dashboardChartData, defaultDashboards_1, deleteDashboard, exportChartToCsv, exportDashboardChartDataToCSV, previewChart, searchDashboards, updateDashboard, validateChart, validateDashboard };

package/dist/dashboards.js

@@ -0,0 +1,67 @@
+import { Jr as _0F4647D9, Kt as _0431356Ce, Lt as _03E75156c, Xr as _0Fd54Ad7, fo as _5A2Fca1e, gi as _1E9E7721, js as _965A3Cb, l as _011E5C4Dd, ns as _6A36C4F8, wn as _052C8Df0a, yr as _074C3078c, yt as _03315F398 } from "./sdk.gen-N-hcF-we.js";
+import { addTenantToParameters, getDataOrThrow, resolveTenant } from "./shared.js";
+//#region src/openapi/sdk/ks-Dashboards.gen.ts
+/**
+* Search for dashboards
+*/
+const searchDashboards = (parameters, options) => getDataOrThrow(_0F4647D9(addTenantToParameters(parameters), options));
+/**
+* Create a dashboard from yaml source
+*/
+const createDashboard = (parameters, options) => getDataOrThrow(_6A36C4F8(addTenantToParameters(parameters), options));
+/**
+* Export a table chart data to CSV
+*/
+const exportChartToCsv = (parameters, options) => getDataOrThrow(_1E9E7721({
+	tenant: resolveTenant(parameters?.tenant),
+	dashboardControllerPreviewRequest: parameters
+}, options));
+/**
+* Preview a chart data
+*/
+const previewChart = (parameters, options) => getDataOrThrow(_052C8Df0a({
+	tenant: resolveTenant(parameters?.tenant),
+	dashboardControllerPreviewRequest: parameters
+}, options));
+/**
+* Get default dashboards
+*/
+const defaultDashboards_1 = (parameters, options) => getDataOrThrow(_0431356Ce(addTenantToParameters(parameters), options));
+/**
+* Validate dashboard from yaml source
+*/
+const validateDashboard = (parameters, options) => getDataOrThrow(_5A2Fca1e(addTenantToParameters(parameters), options));
+/**
+* Validate a chart from yaml source
+*/
+const validateChart = (parameters, options) => getDataOrThrow(_03315F398(addTenantToParameters(parameters), options));
+/**
+* Delete a dashboard
+*/
+const deleteDashboard = (parameters, options) => getDataOrThrow(_0Fd54Ad7(addTenantToParameters(parameters), options));
+/**
+* Get a dashboard
+*/
+const dashboard = (parameters, options) => getDataOrThrow(_03E75156c(addTenantToParameters(parameters), options));
+/**
+* Update a dashboard
+*/
+const updateDashboard = (parameters, options) => getDataOrThrow(_965A3Cb(addTenantToParameters(parameters), options));
+/**
+* Generate a dashboard chart data
+*/
+const dashboardChartData = (parameters, options) => getDataOrThrow(_074C3078c({
+	...parameters,
+	tenant: resolveTenant(parameters?.tenant),
+	chartFiltersOverrides: parameters
+}, options));
+/**
+* Export a dashboard chart data to CSV
+*/
+const exportDashboardChartDataToCSV = (parameters, options) => getDataOrThrow(_011E5C4Dd({
+	...parameters,
+	tenant: resolveTenant(parameters?.tenant),
+	chartFiltersOverrides: parameters
+}, options));
+//#endregion
+export { createDashboard, dashboard, dashboardChartData, defaultDashboards_1, deleteDashboard, exportChartToCsv, exportDashboardChartDataToCSV, previewChart, searchDashboards, updateDashboard, validateChart, validateDashboard };

package/dist/executions.d.ts

@@ -0,0 +1,2 @@
+import { $i as forceRunByIds, Aa as unqueueExecutionsByQuery, Bi as createExecution, Ca as setLabelsOnTerminatedExecutionsByQuery, Da as triggerExecutionByPutWebhookWithPath, Ea as triggerExecutionByPostWebhookWithPath, Gi as evalExpression, Hi as deleteExecutionsByIds, Ji as fileMetadatasFromExecution, Ki as execution, Ma as updateExecutionsStatusByIds, Na as updateExecutionsStatusByQuery, Oa as unqueueExecution, Pa as updateTaskRunState, Qi as followExecution, Sa as setLabelsOnTerminatedExecutionsByIds, Ta as triggerExecutionByGetWebhookWithPath, Ui as deleteExecutionsByQuery, Vi as deleteExecution, Wi as downloadFileFromExecution, Xi as flowFromExecutionById, Yi as flowFromExecution, Zi as followDependenciesExecutions, _a as resumeExecutionsByIds, aa as latestExecutions, ba as searchExecutionsByFlowId, ca as pauseExecutionsByQuery, da as replayExecutionsByIds, ea as forceRunExecution, fa as replayExecutionsByQuery, ga as resumeExecution, ha as restartExecutionsByQuery, ia as killExecutionsByQuery, ja as updateExecutionStatus, ka as unqueueExecutionsByIds, la as replayExecution, ma as restartExecutionsByIds, na as killExecution, oa as pauseExecution, pa as restartExecution, qi as executionFlowGraph, ra as killExecutionsByIds, sa as pauseExecutionsByIds, ta as forceRunExecutionsByQuery, ua as replayExecutionWithinputs, va as resumeExecutionsByQuery, wa as triggerExecutionByGetWebhook, xa as setLabelsOnTerminatedExecution, ya as searchExecutions } from "./index-CpGCUULo.js";
+export { createExecution, deleteExecution, deleteExecutionsByIds, deleteExecutionsByQuery, downloadFileFromExecution, evalExpression, execution, executionFlowGraph, fileMetadatasFromExecution, flowFromExecution, flowFromExecutionById, followDependenciesExecutions, followExecution, forceRunByIds, forceRunExecution, forceRunExecutionsByQuery, killExecution, killExecutionsByIds, killExecutionsByQuery, latestExecutions, pauseExecution, pauseExecutionsByIds, pauseExecutionsByQuery, replayExecution, replayExecutionWithinputs, replayExecutionsByIds, replayExecutionsByQuery, restartExecution, restartExecutionsByIds, restartExecutionsByQuery, resumeExecution, resumeExecutionsByIds, resumeExecutionsByQuery, searchExecutions, searchExecutionsByFlowId, setLabelsOnTerminatedExecution, setLabelsOnTerminatedExecutionsByIds, setLabelsOnTerminatedExecutionsByQuery, triggerExecutionByGetWebhook, triggerExecutionByGetWebhookWithPath, triggerExecutionByPostWebhookWithPath, triggerExecutionByPutWebhookWithPath, unqueueExecution, unqueueExecutionsByIds, unqueueExecutionsByQuery, updateExecutionStatus, updateExecutionsStatusByIds, updateExecutionsStatusByQuery, updateTaskRunState };