windmill-client 1.773.0 → 1.775.0

package/dist/client.d.ts

@@ -435,6 +435,50 @@ export declare class StepSuspend extends Error {
     dispatchInfo: Record<string, any>;
     constructor(dispatchInfo: Record<string, any>);
 }
+/** Values `JSON.stringify` cannot represent: it omits the property holding one.
+ *  The type-level half of `checkpointableResult`, which nulls them at the top
+ *  level, where there is no key to omit. */
+type JsonDropped = ((...args: any[]) => any) | (abstract new (...args: any[]) => any) | symbol;
+/**
+ * What a value looks like after the JSON round trip a checkpoint performs:
+ * `Date` → string, `Map`/`Set` → `{}`, `undefined` → null, methods gone.
+ * `NaN` and the infinities decode as null too, deliberately still typed
+ * `number`: `number | null` everywhere costs more than that case is worth.
+ *
+ * Mirrors `encodeCheckpointPayload` below — keep the two in step, or `step()`
+ * starts describing a value it does not return.
+ */
+export type Jsonified<T> = 0 extends 1 & T ? any : unknown extends T ? unknown : T extends string | number | boolean | null ? T : T extends undefined | void | symbol | ((...args: any[]) => any) ? null : T extends bigint ? string : T extends {
+    toJSON(): infer R;
+} ? Jsonified<R> : T extends ReadonlyMap<any, any> | ReadonlySet<any> ? Record<string, never> : T extends readonly any[] ? {
+    [K in keyof T]: Jsonified<T[K]>;
+} : T extends object ? JsonifiedObject<T> : never;
+/**
+ * `JSON.stringify` keeps own enumerable string keys whose value it can
+ * represent. A key that can only hold an unrepresentable value is gone; one
+ * that merely might becomes optional, because it can come back missing —
+ * `| undefined` alone would still demand the key be there.
+ */
+type JsonifiedObject<T> = Flatten<{
+    [K in keyof T as K extends symbol ? never : [Exclude<T[K], JsonDropped>] extends [never] ? never : [T[K]] extends [Exclude<T[K], JsonDropped>] ? K : never]: Jsonified<T[K]>;
+} & {
+    [K in keyof T as K extends symbol ? never : [Exclude<T[K], JsonDropped>] extends [never] ? never : [T[K]] extends [Exclude<T[K], JsonDropped>] ? never : K]?: Jsonified<Exclude<T[K], JsonDropped>>;
+}>;
+/** Collapse the two halves above into one object, so hovering `Jsonified` shows
+ *  a shape rather than an intersection. */
+type Flatten<T> = {
+    [K in keyof T]: T[K];
+};
+/**
+ * A task function as its callers see it. A task's result always crosses a JSON
+ * boundary — the child job's result is read back from the checkpoint, and the
+ * v1 path reads it back from the API — so only {@link Jsonified} of it survives.
+ *
+ * Rebuilding the signature costs some precision TypeScript cannot preserve: a
+ * generic task's type parameters instantiate at their constraints, and an
+ * overloaded one keeps only its last signature. Neither survives JSON anyway.
+ */
+export type JsonifiedFn<T extends (...args: any[]) => Promise<any>> = (...args: Parameters<T>) => Promise<Jsonified<Awaited<ReturnType<T>>>>;
 export interface TaskOptions {
     timeout?: number;
     tag?: string;
@@ -460,6 +504,11 @@ export declare class WorkflowCtx {
      *  `complete` whose step never reached `completed_steps`. Python is immune:
      *  `_StepSuspend` derives from `BaseException`. */
     private _pendingSuspend;
+    /** The failure raised by the step this child round is executing. That exception
+     *  *is* the round's result, so a `catch` in the body must not be able to turn it
+     *  into a `complete` — the parent would then record the caught branch's value as
+     *  a successful step. Boxed: the thrown value may be any falsy value. */
+    private _pendingStepFailure;
     /** When set, the task matching this key executes its inner function directly */
     _executingKey: string | null;
     /** Serializes fast-path POSTs across concurrent step() calls within one
@@ -502,18 +551,33 @@ export declare class WorkflowCtx {
     /** Raise a suspend, parking it so a body that catches it cannot make it
      *  vanish. Every suspend raised for this ctx must go through here. */
     _raiseSuspend(dispatchInfo: Record<string, any>): never;
-    /** Re-throw a swallowed suspend at the next SDK call. It happened before
-     *  whatever the body is doing now, so it wins: the run is unwinding either
-     *  way and everything after it re-runs on the replay. Left set, so a body
-     *  that catches in a loop can't swallow it a second time. */
-    private _rethrowSwallowedSuspend;
+    /** Park then raise the executing step's failure. Child mode only — in a parent
+     *  round a task failure is an ordinary `TaskError` the body may handle. */
+    _raiseStepFailure(error: unknown): never;
+    /** Re-throw a swallowed suspend or step failure at the next SDK call. It
+     *  happened before whatever the body is doing now, so it wins: the run is
+     *  unwinding either way and everything after it re-runs on the replay. Left
+     *  set, so a body that catches in a loop can't swallow it a second time. */
+    private _rethrowSwallowed;
     /** Hand the runner a suspend the workflow body caught and swallowed, so it is
      *  honoured instead of silently turning into a `complete`. Returns null when
      *  the suspend propagated normally. */
     _takePendingSuspend(): StepSuspend | null;
+    /** Same for the executing step's failure, so the runner can fail the child job. */
+    _takePendingStepFailure(): {
+        error: unknown;
+    } | null;
 }
 export declare function sleep(seconds: number): Promise<void>;
-export declare function step<T>(name: string, fn: () => T | Promise<T>): Promise<T>;
+/**
+ * Execute `fn` inline and checkpoint the result. On replay the cached value is
+ * returned without re-executing `fn`.
+ *
+ * `fn`'s result is encoded as JSON and decoded back before it is returned, so
+ * the round that runs the body sees the same types every replay sees: a `Date`
+ * comes back as a string, a `Map` as `{}`. {@link Jsonified} is that shape.
+ */
+export declare function step<T>(name: string, fn: () => T | Promise<T>): Promise<Jsonified<Awaited<T>>>;
 /**
  * Wrap an async function as a workflow task.
  *
@@ -523,8 +587,12 @@ export declare function step<T>(name: string, fn: () => T | Promise<T>): Promise
  *
  * Inside a `workflow()`, calling a task dispatches it as a step.
  * Outside a workflow, the function body executes directly.
+ *
+ * A task runs as its own job, so its result is always encoded as JSON and
+ * decoded back before the caller sees it: a `Date` comes back as a string, a
+ * `Map` as `{}`. {@link JsonifiedFn} is that shape.
  */
-export declare function task<T extends (...args: any[]) => Promise<any>>(fnOrPath: T | string, maybeFnOrOptions?: T | TaskOptions, maybeOptions?: TaskOptions): T;
+export declare function task<T extends (...args: any[]) => Promise<any>>(fnOrPath: T | string, maybeFnOrOptions?: T | TaskOptions, maybeOptions?: TaskOptions): JsonifiedFn<T>;
 /**
  * Create a task that dispatches to a separate Windmill script.
  *

package/dist/client.mjs

@@ -1,5 +1,6 @@
 import { OpenAPI } from "./core/OpenAPI.mjs";
 import { AppService, HelpersService, JobService, KafkaTriggerService, MetricsService, OidcService, ResourceService, UserService, VariableService } from "./services.gen.mjs";
+import { isSuspendSignal, stepErrorMarker, taskErrorFromMarker } from "./wacError.mjs";
 import { parseS3Object } from "./s3Types.mjs";
 import { appendPartition, datatable, ducklake, upsertPartition } from "./sqlUtils.mjs";
 
@@ -958,31 +959,24 @@ var StepSuspend = class extends Error {
 		this.name = "StepSuspend";
 	}
 };
-/** Serialize a failed `step()` body into the `__wmill_error` marker that task
-*  failures also use, so it can be stored in `completed_steps`. */
-function stepErrorMarker(key, e) {
-	const message = e instanceof Error ? e.message : String(e);
-	const type = e instanceof Error ? e.constructor?.name ?? e.name : typeof e;
-	return {
-		__wmill_error: true,
-		message,
-		step_key: key,
-		result: {
-			error: message,
-			type
-		}
-	};
-}
-/** Rebuild the error a failed step throws. Both the run that produced the
-*  failure and every later replay go through here, so a workflow's catch block
-*  sees the same shape either way. */
-function stepErrorFromMarker(marker, name) {
-	const err = new Error(marker?.message || `Step '${name}' failed`);
-	err.name = "TaskError";
-	err.result = marker?.result;
-	err.step_key = marker?.step_key;
-	err.child_job_id = marker?.child_job_id;
-	return err;
+/** Encode a checkpoint payload the way the worker wrapper does on the suspend
+*  path, so both arms record the same value for the same step. `undefined` maps
+*  to null; a bigint to its digits, which the wrapper gets instead from the
+*  `BigInt.prototype.toJSON` it installs and the SDK cannot count on. */
+function encodeCheckpointPayload(payload) {
+	return JSON.stringify(payload, (_key, value) => typeof value === "undefined" ? null : typeof value === "bigint" ? value.toString() : value);
+}
+/** A whole result that `JSON.stringify` drops the key for leaves a checkpoint
+*  with no `result`, which neither the endpoint nor `WacOutput` accepts. Only
+*  the top level: nested, a dropped key is what every other bun path does. */
+function checkpointableResult(value) {
+	return typeof value === "function" || typeof value === "symbol" ? null : value;
+}
+/** Put a value through the checkpoint's encoding without checkpointing it, so
+*  the paths that never persist anything still hand back the shape the ones
+*  that do would. */
+function jsonRoundTrip(value) {
+	return JSON.parse(encodeCheckpointPayload({ value: checkpointableResult(value) })).value;
 }
 /** A step key travels as one path segment when its URLs are minted, so it must be
 *  non-empty and free of `/` and dot segments — otherwise `waitForApproval` would
@@ -1010,6 +1004,11 @@ var WorkflowCtx = class {
 	*  `complete` whose step never reached `completed_steps`. Python is immune:
 	*  `_StepSuspend` derives from `BaseException`. */
 	_pendingSuspend = null;
+	/** The failure raised by the step this child round is executing. That exception
+	*  *is* the round's result, so a `catch` in the body must not be able to turn it
+	*  into a `complete` — the parent would then record the caught branch's value as
+	*  a successful step. Boxed: the thrown value may be any falsy value. */
+	_pendingStepFailure = null;
 	/** When set, the task matching this key executes its inner function directly */
 	_executingKey;
 	/** Serializes fast-path POSTs across concurrent step() calls within one
@@ -1042,16 +1041,12 @@ var WorkflowCtx = class {
 		return key;
 	}
 	_nextStep(name, script, args = {}, dispatch_type = "inline", options) {
-		this._rethrowSwallowedSuspend();
+		this._rethrowSwallowed();
 		const key = this._allocKey(name || script || "step");
 		if (key in this.completed) {
 			const value = this.completed[key];
 			if (value && typeof value === "object" && value.__wmill_error) {
-				const err = new Error(value.message || `Task '${name}' failed`);
-				err.name = "TaskError";
-				err.result = value.result;
-				err.step_key = value.step_key;
-				err.child_job_id = value.child_job_id;
+				const err = taskErrorFromMarker(value, `Task '${name}' failed`);
 				return { then: (_resolve, reject) => {
 					if (reject) reject(err);
 					else throw err;
@@ -1101,7 +1096,7 @@ var WorkflowCtx = class {
 		return steps;
 	}
 	_waitForApproval(options) {
-		this._rethrowSwallowedSuspend();
+		this._rethrowSwallowed();
 		if (options?.key !== void 0) assertUsableStepKey(options.key, "waitForApproval key");
 		const key = this._allocKey(options?.key || "approval");
 		if (options?.key && key !== options.key) throw new Error(`WAC step key "${options.key}" is already used in this workflow. Give each waitForApproval() its own key so getApprovalUrls() can address it.`);
@@ -1121,7 +1116,7 @@ var WorkflowCtx = class {
 		});
 	}
 	_sleep(seconds) {
-		this._rethrowSwallowedSuspend();
+		this._rethrowSwallowed();
 		const key = this._allocKey("sleep");
 		if (key in this.completed) return { then: (resolve) => resolve(void 0) };
 		if (this._executingKey !== null) return { then: () => new Promise(() => {}) };
@@ -1134,11 +1129,11 @@ var WorkflowCtx = class {
 		});
 	}
 	async _runInlineStep(name, fn) {
-		this._rethrowSwallowedSuspend();
+		this._rethrowSwallowed();
 		const key = this._allocKey(name || "step");
 		if (key in this.completed) {
 			const value = this.completed[key];
-			if (value && typeof value === "object" && value.__wmill_error) throw stepErrorFromMarker(value, name);
+			if (value && typeof value === "object" && value.__wmill_error) throw taskErrorFromMarker(value, `Step '${name}' failed`);
 			return value;
 		}
 		if (this._executingKey !== null) return new Promise(() => {});
@@ -1150,22 +1145,36 @@ var WorkflowCtx = class {
 		})}`);
 		const t0 = Date.now();
 		let result;
-		let stepError;
 		let errored = false;
 		try {
 			result = await fn();
 		} catch (e) {
-			if (e?.name === "StepSuspend" || e instanceof StepSuspend) throw e;
+			if (isSuspendSignal(e, StepSuspend)) throw e;
 			errored = true;
-			stepError = e;
 			result = stepErrorMarker(key, e);
+			console.log(`--- WAC: ${key} failed ---`);
+			console.log(result?.result?.error?.stack ?? result?.message ?? "step failed");
 		}
 		const durationMs = Date.now() - t0;
 		const fastPathFlagRaw = (getEnv("WM_WAC_INLINE_FAST_PATH") ?? "1").trim().toLowerCase();
 		const fastPathEnabled = fastPathFlagRaw !== "0" && fastPathFlagRaw !== "false" && fastPathFlagRaw !== "off" && fastPathFlagRaw !== "no";
 		const jobId = getEnv("WM_JOB_ID");
 		const workspace = getEnv("WM_WORKSPACE");
-		if (fastPathEnabled && jobId && workspace && OpenAPI.BASE && OpenAPI.TOKEN) {
+		let payload;
+		let checkpointed;
+		if (fastPathEnabled && jobId && workspace && OpenAPI.BASE && OpenAPI.TOKEN) try {
+			payload = encodeCheckpointPayload({
+				key,
+				result: checkpointableResult(result),
+				started_at: startedAt,
+				duration_ms: durationMs
+			});
+			checkpointed = JSON.parse(payload).result;
+		} catch (e) {
+			console.log(`WAC v2 inline fast path could not serialize key ${key}, falling back to suspend: ${e}`);
+		}
+		if (payload !== void 0) {
+			const body = payload;
 			const chainTail = this._inlineChain.then(async () => {
 				const ctrl = new AbortController();
 				const t = setTimeout(() => ctrl.abort(), 1e4);
@@ -1176,37 +1185,36 @@ var WorkflowCtx = class {
 							"Content-Type": "application/json",
 							Authorization: `Bearer ${OpenAPI.TOKEN}`
 						},
-						body: JSON.stringify({
-							key,
-							result,
-							started_at: startedAt,
-							duration_ms: durationMs
-						}),
+						body,
 						signal: ctrl.signal
 					});
 					if (!resp.ok) throw new Error(`inline_checkpoint API ${resp.status}`);
+					if (!errored) return void 0;
+					if (!(resp.headers.get("content-type") ?? "").includes("json")) return void 0;
+					return (await resp.json())?.failure;
 				} finally {
 					clearTimeout(t);
 				}
 			});
 			this._inlineChain = chainTail.catch(() => {});
 			let fastPathOk = false;
+			let storedFailure;
 			try {
-				await chainTail;
+				storedFailure = await chainTail;
 				fastPathOk = true;
 			} catch (e) {
 				console.log(`WAC v2 inline fast path failed for key ${key}, falling back to suspend: ${e}`);
 			}
 			if (fastPathOk) {
-				if (errored) throw Object.assign(stepErrorFromMarker(result, name), { cause: stepError });
-				return result;
+				if (errored) throw taskErrorFromMarker(storedFailure ?? checkpointed, `Step '${name}' failed`);
+				return checkpointed;
 			}
 		}
 		this._raiseSuspend({
 			mode: "inline_checkpoint",
 			steps: [],
 			key,
-			result,
+			result: checkpointableResult(result),
 			started_at: startedAt,
 			duration_ms: durationMs
 		});
@@ -1218,11 +1226,18 @@ var WorkflowCtx = class {
 		this._pendingSuspend = suspend;
 		throw suspend;
 	}
-	/** Re-throw a swallowed suspend at the next SDK call. It happened before
-	*  whatever the body is doing now, so it wins: the run is unwinding either
-	*  way and everything after it re-runs on the replay. Left set, so a body
-	*  that catches in a loop can't swallow it a second time. */
-	_rethrowSwallowedSuspend() {
+	/** Park then raise the executing step's failure. Child mode only — in a parent
+	*  round a task failure is an ordinary `TaskError` the body may handle. */
+	_raiseStepFailure(error) {
+		this._pendingStepFailure = { error };
+		throw error;
+	}
+	/** Re-throw a swallowed suspend or step failure at the next SDK call. It
+	*  happened before whatever the body is doing now, so it wins: the run is
+	*  unwinding either way and everything after it re-runs on the replay. Left
+	*  set, so a body that catches in a loop can't swallow it a second time. */
+	_rethrowSwallowed() {
+		if (this._pendingStepFailure) throw this._pendingStepFailure.error;
 		if (this._pendingSuspend) throw this._pendingSuspend;
 	}
 	/** Hand the runner a suspend the workflow body caught and swallowed, so it is
@@ -1233,16 +1248,30 @@ var WorkflowCtx = class {
 		this._pendingSuspend = null;
 		return s;
 	}
+	/** Same for the executing step's failure, so the runner can fail the child job. */
+	_takePendingStepFailure() {
+		const f = this._pendingStepFailure;
+		this._pendingStepFailure = null;
+		return f;
+	}
 };
 async function sleep(seconds) {
 	const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
 	if (ctx) return ctx._sleep(seconds);
 	await new Promise((r) => setTimeout(r, seconds * 1e3));
 }
+/**
+* Execute `fn` inline and checkpoint the result. On replay the cached value is
+* returned without re-executing `fn`.
+*
+* `fn`'s result is encoded as JSON and decoded back before it is returned, so
+* the round that runs the body sees the same types every replay sees: a `Date`
+* comes back as a string, a `Map` as `{}`. {@link Jsonified} is that shape.
+*/
 async function step(name, fn) {
 	const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
 	if (ctx) return ctx._runInlineStep(name, fn);
-	return fn();
+	return jsonRoundTrip(await fn());
 }
 /**
 * Wrap an async function as a workflow task.
@@ -1253,6 +1282,10 @@ async function step(name, fn) {
 *
 * Inside a `workflow()`, calling a task dispatches it as a step.
 * Outside a workflow, the function body executes directly.
+*
+* A task runs as its own job, so its result is always encoded as JSON and
+* decoded back before the caller sees it: a `Date` comes back as a string, a
+* `Map` as `{}`. {@link JsonifiedFn} is that shape.
 */
 function task(fnOrPath, maybeFnOrOptions, maybeOptions) {
 	let fn;
@@ -1277,11 +1310,17 @@ function task(fnOrPath, maybeFnOrOptions, maybeOptions) {
 			else kwargs[`arg${i}`] = args[i];
 			const stepResult = ctx._nextStep(taskName, script, kwargs, "inline", taskOptions);
 			if (stepResult?._execute_directly) return (async () => {
-				const result = await fn(...args);
+				let result;
+				try {
+					result = await fn(...args);
+				} catch (e) {
+					if (isSuspendSignal(e, StepSuspend)) throw e;
+					ctx._raiseStepFailure(e);
+				}
 				ctx._raiseSuspend({
 					mode: "step_complete",
 					steps: [],
-					result
+					result: checkpointableResult(result)
 				});
 			})();
 			return stepResult;
@@ -1303,7 +1342,7 @@ function task(fnOrPath, maybeFnOrOptions, maybeOptions) {
 			console.log(`Task ${taskName} (${jobId}) completed`);
 			return r;
 		})();
-		else return fn(...args);
+		else return Promise.resolve(fn(...args)).then(jsonRoundTrip);
 	};
 	Object.defineProperty(wrapper, "name", { value: taskName });
 	wrapper._is_task = true;

package/dist/core/OpenAPI.mjs

@@ -29,7 +29,7 @@ const OpenAPI = {
 	PASSWORD: void 0,
 	TOKEN: getEnv("WM_TOKEN"),
 	USERNAME: void 0,
-	VERSION: "1.773.0",
+	VERSION: "1.775.0",
 	WITH_CREDENTIALS: true,
 	interceptors: {
 		request: new Interceptors(),

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { OpenAPI, type OpenAPIConfig } from './core/OpenAPI';
 export * from './services.gen';
 export * from './types.gen';
 export type { DenoS3LightClientSettings } from "./s3Types";
-export { type Base64, setClient, getVariable, setVariable, getResource, setResource, getResumeUrls, setState, setProgress, getProgress, getState, getIdToken, denoS3LightClientSettings, loadS3FileStream, loadS3File, writeS3File, deleteS3File, signS3Objects, signS3Object, getPresignedS3PublicUrls, getPresignedS3PublicUrl, task, taskScript, taskFlow, workflow, step, sleep, parallel, waitForApproval, getApprovalUrls, type TaskOptions, WorkflowCtx, _workflowCtx, setWorkflowCtx, StepSuspend, runScript, runScriptAsync, runScriptByPath, runScriptByHash, runScriptByPathAsync, runScriptByHashAsync, runFlow, runFlowAsync, waitJob, getRootJobId, setFlowUserState, getFlowUserState, usernameToEmail, requestInteractiveSlackApproval, type Sql, requestInteractiveTeamsApproval, appendToResultStream, streamResult, datatable, ducklake, upsertPartition, appendPartition, type DucklakeMaterializeOptions, type SqlStatement, type DatatableSqlTemplateFunction, type SqlTemplateFunction, type S3Object, type S3ObjectRecord, type S3ObjectURI, commitKafkaOffsets } from "./client";
+export { type Base64, setClient, getVariable, setVariable, getResource, setResource, getResumeUrls, setState, setProgress, getProgress, getState, getIdToken, denoS3LightClientSettings, loadS3FileStream, loadS3File, writeS3File, deleteS3File, signS3Objects, signS3Object, getPresignedS3PublicUrls, getPresignedS3PublicUrl, task, taskScript, taskFlow, workflow, step, sleep, parallel, waitForApproval, getApprovalUrls, type TaskOptions, type Jsonified, type JsonifiedFn, WorkflowCtx, _workflowCtx, setWorkflowCtx, StepSuspend, runScript, runScriptAsync, runScriptByPath, runScriptByHash, runScriptByPathAsync, runScriptByHashAsync, runFlow, runFlowAsync, waitJob, getRootJobId, setFlowUserState, getFlowUserState, usernameToEmail, requestInteractiveSlackApproval, type Sql, requestInteractiveTeamsApproval, appendToResultStream, streamResult, datatable, ducklake, upsertPartition, appendPartition, type DucklakeMaterializeOptions, type SqlStatement, type DatatableSqlTemplateFunction, type SqlTemplateFunction, type S3Object, type S3ObjectRecord, type S3ObjectURI, commitKafkaOffsets } from "./client";
 import { setClient, getVariable, setVariable, getResource, setResource, getResumeUrls, setState, setProgress, getProgress, getState, getIdToken, denoS3LightClientSettings, loadS3FileStream, loadS3File, writeS3File, deleteS3File, signS3Objects, signS3Object, getPresignedS3PublicUrls, getPresignedS3PublicUrl, task, taskScript, taskFlow, workflow, step, sleep, parallel, waitForApproval, getApprovalUrls, WorkflowCtx, setWorkflowCtx, StepSuspend, runScript, runScriptAsync, runScriptByPath, runScriptByHash, runScriptByPathAsync, runScriptByHashAsync, runFlow, runFlowAsync, waitJob, getRootJobId, setFlowUserState, getFlowUserState, usernameToEmail, requestInteractiveSlackApproval, requestInteractiveTeamsApproval, appendToResultStream, streamResult, datatable, ducklake, upsertPartition, appendPartition, getWorkspace, getStatePath, getInternalState, setInternalState, getResumeEndpoints, getResult, getResultMaybe, resolveDefaultResource, databaseUrlFromResource, base64ToUint8Array, uint8ArrayToBase64, parseS3Object, commitKafkaOffsets } from "./client";
 import { AdminService, AuditService, FlowService, GranularAclService, GroupService, JobService, ResourceService, VariableService, ScriptService, ScheduleService, SettingsService, UserService, WorkspaceService, TeamsService } from "./services.gen";
 declare const wmill: {