@powerhousedao/workflow 6.2.3-dev.13 → 6.2.3-dev.15

package/dist/node/pieces/reactor/index.mjs

@@ -1,18 +1,1382 @@
-import * as z from "zod/mini";
 import crypto from "crypto";
+Object.freeze({ status: "aborted" });
+function $constructor(name, initializer, params) {
+	function init(inst, def) {
+		if (!inst._zod) Object.defineProperty(inst, "_zod", {
+			value: {
+				def,
+				constr: _,
+				traits: /* @__PURE__ */ new Set()
+			},
+			enumerable: false
+		});
+		if (inst._zod.traits.has(name)) return;
+		inst._zod.traits.add(name);
+		initializer(inst, def);
+		const proto = _.prototype;
+		const keys = Object.keys(proto);
+		for (let i = 0; i < keys.length; i++) {
+			const k = keys[i];
+			if (!(k in inst)) inst[k] = proto[k].bind(inst);
+		}
+	}
+	const Parent = params?.Parent ?? Object;
+	class Definition extends Parent {}
+	Object.defineProperty(Definition, "name", { value: name });
+	function _(def) {
+		var _a;
+		const inst = params?.Parent ? new Definition() : this;
+		init(inst, def);
+		(_a = inst._zod).deferred ?? (_a.deferred = []);
+		for (const fn of inst._zod.deferred) fn();
+		return inst;
+	}
+	Object.defineProperty(_, "init", { value: init });
+	Object.defineProperty(_, Symbol.hasInstance, { value: (inst) => {
+		if (params?.Parent && inst instanceof params.Parent) return true;
+		return inst?._zod?.traits?.has(name);
+	} });
+	Object.defineProperty(_, "name", { value: name });
+	return _;
+}
+var $ZodAsyncError = class extends Error {
+	constructor() {
+		super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+	}
+};
+var $ZodEncodeError = class extends Error {
+	constructor(name) {
+		super(`Encountered unidirectional transform during encode: ${name}`);
+		this.name = "ZodEncodeError";
+	}
+};
+const globalConfig = {};
+function config(newConfig) {
+	if (newConfig) Object.assign(globalConfig, newConfig);
+	return globalConfig;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/util.js
+function getEnumValues(entries) {
+	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+}
+function jsonStringifyReplacer(_, value) {
+	if (typeof value === "bigint") return value.toString();
+	return value;
+}
+function cached(getter) {
+	return { get value() {
+		{
+			const value = getter();
+			Object.defineProperty(this, "value", { value });
+			return value;
+		}
+		throw new Error("cached value already set");
+	} };
+}
+function nullish(input) {
+	return input === null || input === void 0;
+}
+function cleanRegex(source) {
+	const start = source.startsWith("^") ? 1 : 0;
+	const end = source.endsWith("$") ? source.length - 1 : source.length;
+	return source.slice(start, end);
+}
+const EVALUATING = Symbol("evaluating");
+function defineLazy(object, key, getter) {
+	let value = void 0;
+	Object.defineProperty(object, key, {
+		get() {
+			if (value === EVALUATING) return;
+			if (value === void 0) {
+				value = EVALUATING;
+				value = getter();
+			}
+			return value;
+		},
+		set(v) {
+			Object.defineProperty(object, key, { value: v });
+		},
+		configurable: true
+	});
+}
+const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+function isObject(data) {
+	return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+cached(() => {
+	if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) return false;
+	try {
+		new Function("");
+		return true;
+	} catch (_) {
+		return false;
+	}
+});
+function isPlainObject(o) {
+	if (isObject(o) === false) return false;
+	const ctor = o.constructor;
+	if (ctor === void 0) return true;
+	if (typeof ctor !== "function") return true;
+	const prot = ctor.prototype;
+	if (isObject(prot) === false) return false;
+	if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
+	return true;
+}
+const propertyKeyTypes = new Set([
+	"string",
+	"number",
+	"symbol"
+]);
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(inst, def, params) {
+	const cl = new inst._zod.constr(def ?? inst._zod.def);
+	if (!def || params?.parent) cl._zod.parent = inst;
+	return cl;
+}
+function normalizeParams(_params) {
+	const params = _params;
+	if (!params) return {};
+	if (typeof params === "string") return { error: () => params };
+	if (params?.message !== void 0) {
+		if (params?.error !== void 0) throw new Error("Cannot specify both `message` and `error` params");
+		params.error = params.message;
+	}
+	delete params.message;
+	if (typeof params.error === "string") return {
+		...params,
+		error: () => params.error
+	};
+	return params;
+}
+function optionalKeys(shape) {
+	return Object.keys(shape).filter((k) => {
+		return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+	});
+}
+Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER, -Number.MAX_VALUE, Number.MAX_VALUE;
+function aborted(x, startIndex = 0) {
+	if (x.aborted === true) return true;
+	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
+	return false;
+}
+function prefixIssues(path, issues) {
+	return issues.map((iss) => {
+		var _a;
+		(_a = iss).path ?? (_a.path = []);
+		iss.path.unshift(path);
+		return iss;
+	});
+}
+function unwrapMessage(message) {
+	return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config) {
+	const full = {
+		...iss,
+		path: iss.path ?? []
+	};
+	if (!iss.message) full.message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
+	delete full.inst;
+	delete full.continue;
+	if (!ctx?.reportInput) delete full.input;
+	return full;
+}
+function getLengthableOrigin(input) {
+	if (Array.isArray(input)) return "array";
+	if (typeof input === "string") return "string";
+	return "unknown";
+}
+function issue(...args) {
+	const [iss, input, inst] = args;
+	if (typeof iss === "string") return {
+		message: iss,
+		code: "custom",
+		input,
+		inst
+	};
+	return { ...iss };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/errors.js
+const initializer = (inst, def) => {
+	inst.name = "$ZodError";
+	Object.defineProperty(inst, "_zod", {
+		value: inst._zod,
+		enumerable: false
+	});
+	Object.defineProperty(inst, "issues", {
+		value: def,
+		enumerable: false
+	});
+	inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+	Object.defineProperty(inst, "toString", {
+		value: () => inst.message,
+		enumerable: false
+	});
+};
+const $ZodError = $constructor("$ZodError", initializer);
+const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/parse.js
+const _parse = (_Err) => (schema, value, _ctx, _params) => {
+	const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+	const result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) throw new $ZodAsyncError();
+	if (result.issues.length) {
+		const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+		captureStackTrace(e, _params?.callee);
+		throw e;
+	}
+	return result.value;
+};
+const parse = /* @__PURE__ */ _parse($ZodRealError);
+const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+	let result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) result = await result;
+	if (result.issues.length) {
+		const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+		captureStackTrace(e, params?.callee);
+		throw e;
+	}
+	return result.value;
+};
+const parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
+const _safeParse = (_Err) => (schema, value, _ctx) => {
+	const ctx = _ctx ? {
+		..._ctx,
+		async: false
+	} : { async: false };
+	const result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) throw new $ZodAsyncError();
+	return result.issues.length ? {
+		success: false,
+		error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+	} : {
+		success: true,
+		data: result.value
+	};
+};
+const safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
+const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+	let result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) result = await result;
+	return result.issues.length ? {
+		success: false,
+		error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+	} : {
+		success: true,
+		data: result.value
+	};
+};
+const safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+const string$1 = (params) => {
+	const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+	return new RegExp(`^${regex}$`);
+};
+const number$2 = /^-?\d+(?:\.\d+)?$/;
+const boolean$1 = /^(?:true|false)$/i;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.js
+const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+	var _a;
+	inst._zod ?? (inst._zod = {});
+	inst._zod.def = def;
+	(_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+const $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
+	var _a;
+	$ZodCheck.init(inst, def);
+	(_a = inst._zod.def).when ?? (_a.when = (payload) => {
+		const val = payload.value;
+		return !nullish(val) && val.length !== void 0;
+	});
+	inst._zod.onattach.push((inst) => {
+		const curr = inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
+		if (def.minimum > curr) inst._zod.bag.minimum = def.minimum;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		if (input.length >= def.minimum) return;
+		const origin = getLengthableOrigin(input);
+		payload.issues.push({
+			origin,
+			code: "too_small",
+			minimum: def.minimum,
+			inclusive: true,
+			input,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
+	var _a, _b;
+	$ZodCheck.init(inst, def);
+	inst._zod.onattach.push((inst) => {
+		const bag = inst._zod.bag;
+		bag.format = def.format;
+		if (def.pattern) {
+			bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+			bag.patterns.add(def.pattern);
+		}
+	});
+	if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload) => {
+		def.pattern.lastIndex = 0;
+		if (def.pattern.test(payload.value)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: def.format,
+			input: payload.value,
+			...def.pattern ? { pattern: def.pattern.toString() } : {},
+			inst,
+			continue: !def.abort
+		});
+	});
+	else (_b = inst._zod).check ?? (_b.check = () => {});
+});
+const $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
+	$ZodCheckStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		def.pattern.lastIndex = 0;
+		if (def.pattern.test(payload.value)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "regex",
+			input: payload.value,
+			pattern: def.pattern.toString(),
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/versions.js
+const version = {
+	major: 4,
+	minor: 3,
+	patch: 6
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/schemas.js
+const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
+	var _a;
+	inst ?? (inst = {});
+	inst._zod.def = def;
+	inst._zod.bag = inst._zod.bag || {};
+	inst._zod.version = version;
+	const checks = [...inst._zod.def.checks ?? []];
+	if (inst._zod.traits.has("$ZodCheck")) checks.unshift(inst);
+	for (const ch of checks) for (const fn of ch._zod.onattach) fn(inst);
+	if (checks.length === 0) {
+		(_a = inst._zod).deferred ?? (_a.deferred = []);
+		inst._zod.deferred?.push(() => {
+			inst._zod.run = inst._zod.parse;
+		});
+	} else {
+		const runChecks = (payload, checks, ctx) => {
+			let isAborted = aborted(payload);
+			let asyncResult;
+			for (const ch of checks) {
+				if (ch._zod.def.when) {
+					if (!ch._zod.def.when(payload)) continue;
+				} else if (isAborted) continue;
+				const currLen = payload.issues.length;
+				const _ = ch._zod.check(payload);
+				if (_ instanceof Promise && ctx?.async === false) throw new $ZodAsyncError();
+				if (asyncResult || _ instanceof Promise) asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+					await _;
+					if (payload.issues.length === currLen) return;
+					if (!isAborted) isAborted = aborted(payload, currLen);
+				});
+				else {
+					if (payload.issues.length === currLen) continue;
+					if (!isAborted) isAborted = aborted(payload, currLen);
+				}
+			}
+			if (asyncResult) return asyncResult.then(() => {
+				return payload;
+			});
+			return payload;
+		};
+		const handleCanaryResult = (canary, payload, ctx) => {
+			if (aborted(canary)) {
+				canary.aborted = true;
+				return canary;
+			}
+			const checkResult = runChecks(payload, checks, ctx);
+			if (checkResult instanceof Promise) {
+				if (ctx.async === false) throw new $ZodAsyncError();
+				return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));
+			}
+			return inst._zod.parse(checkResult, ctx);
+		};
+		inst._zod.run = (payload, ctx) => {
+			if (ctx.skipChecks) return inst._zod.parse(payload, ctx);
+			if (ctx.direction === "backward") {
+				const canary = inst._zod.parse({
+					value: payload.value,
+					issues: []
+				}, {
+					...ctx,
+					skipChecks: true
+				});
+				if (canary instanceof Promise) return canary.then((canary) => {
+					return handleCanaryResult(canary, payload, ctx);
+				});
+				return handleCanaryResult(canary, payload, ctx);
+			}
+			const result = inst._zod.parse(payload, ctx);
+			if (result instanceof Promise) {
+				if (ctx.async === false) throw new $ZodAsyncError();
+				return result.then((result) => runChecks(result, checks, ctx));
+			}
+			return runChecks(result, checks, ctx);
+		};
+	}
+	defineLazy(inst, "~standard", () => ({
+		validate: (value) => {
+			try {
+				const r = safeParse(inst, value);
+				return r.success ? { value: r.data } : { issues: r.error?.issues };
+			} catch (_) {
+				return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
+			}
+		},
+		vendor: "zod",
+		version: 1
+	}));
+});
+const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string$1(inst._zod.bag);
+	inst._zod.parse = (payload, _) => {
+		if (def.coerce) try {
+			payload.value = String(payload.value);
+		} catch (_) {}
+		if (typeof payload.value === "string") return payload;
+		payload.issues.push({
+			expected: "string",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = inst._zod.bag.pattern ?? number$2;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Number(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) return payload;
+		const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
+		payload.issues.push({
+			expected: "number",
+			code: "invalid_type",
+			input,
+			inst,
+			...received ? { received } : {}
+		});
+		return payload;
+	};
+});
+const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = boolean$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Boolean(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "boolean") return payload;
+		payload.issues.push({
+			expected: "boolean",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload) => payload;
+});
+const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload) => payload;
+});
+const $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (typeof input === "undefined") return payload;
+		payload.issues.push({
+			expected: "void",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+function handleArrayResult(result, final, index) {
+	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
+	final.value[index] = result.value;
+}
+const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!Array.isArray(input)) {
+			payload.issues.push({
+				expected: "array",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		payload.value = Array(input.length);
+		const proms = [];
+		for (let i = 0; i < input.length; i++) {
+			const item = input[i];
+			const result = def.element._zod.run({
+				value: item,
+				issues: []
+			}, ctx);
+			if (result instanceof Promise) proms.push(result.then((result) => handleArrayResult(result, payload, i)));
+			else handleArrayResult(result, payload, i);
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
+function handlePropertyResult(result, final, key, input, isOptionalOut) {
+	if (result.issues.length) {
+		if (isOptionalOut && !(key in input)) return;
+		final.issues.push(...prefixIssues(key, result.issues));
+	}
+	if (result.value === void 0) {
+		if (key in input) final.value[key] = void 0;
+	} else final.value[key] = result.value;
+}
+function normalizeDef(def) {
+	const keys = Object.keys(def.shape);
+	for (const k of keys) if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+	const okeys = optionalKeys(def.shape);
+	return {
+		...def,
+		keys,
+		keySet: new Set(keys),
+		numKeys: keys.length,
+		optionalKeys: new Set(okeys)
+	};
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+	const unrecognized = [];
+	const keySet = def.keySet;
+	const _catchall = def.catchall._zod;
+	const t = _catchall.def.type;
+	const isOptionalOut = _catchall.optout === "optional";
+	for (const key in input) {
+		if (keySet.has(key)) continue;
+		if (t === "never") {
+			unrecognized.push(key);
+			continue;
+		}
+		const r = _catchall.run({
+			value: input[key],
+			issues: []
+		}, ctx);
+		if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
+		else handlePropertyResult(r, payload, key, input, isOptionalOut);
+	}
+	if (unrecognized.length) payload.issues.push({
+		code: "unrecognized_keys",
+		keys: unrecognized,
+		input,
+		inst
+	});
+	if (!proms.length) return payload;
+	return Promise.all(proms).then(() => {
+		return payload;
+	});
+}
+const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+	$ZodType.init(inst, def);
+	if (!Object.getOwnPropertyDescriptor(def, "shape")?.get) {
+		const sh = def.shape;
+		Object.defineProperty(def, "shape", { get: () => {
+			const newSh = { ...sh };
+			Object.defineProperty(def, "shape", { value: newSh });
+			return newSh;
+		} });
+	}
+	const _normalized = cached(() => normalizeDef(def));
+	defineLazy(inst._zod, "propValues", () => {
+		const shape = def.shape;
+		const propValues = {};
+		for (const key in shape) {
+			const field = shape[key]._zod;
+			if (field.values) {
+				propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+				for (const v of field.values) propValues[key].add(v);
+			}
+		}
+		return propValues;
+	});
+	const isObject$2 = isObject;
+	const catchall = def.catchall;
+	let value;
+	inst._zod.parse = (payload, ctx) => {
+		value ?? (value = _normalized.value);
+		const input = payload.value;
+		if (!isObject$2(input)) {
+			payload.issues.push({
+				expected: "object",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		payload.value = {};
+		const proms = [];
+		const shape = value.shape;
+		for (const key of value.keys) {
+			const el = shape[key];
+			const isOptionalOut = el._zod.optout === "optional";
+			const r = el._zod.run({
+				value: input[key],
+				issues: []
+			}, ctx);
+			if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
+			else handlePropertyResult(r, payload, key, input, isOptionalOut);
+		}
+		if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;
+		return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+	};
+});
+function handleUnionResults(results, final, inst, ctx) {
+	for (const result of results) if (result.issues.length === 0) {
+		final.value = result.value;
+		return final;
+	}
+	const nonaborted = results.filter((r) => !aborted(r));
+	if (nonaborted.length === 1) {
+		final.value = nonaborted[0].value;
+		return nonaborted[0];
+	}
+	final.issues.push({
+		code: "invalid_union",
+		input: final.value,
+		inst,
+		errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+	});
+	return final;
+}
+const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
+	defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
+	defineLazy(inst._zod, "values", () => {
+		if (def.options.every((o) => o._zod.values)) return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+	});
+	defineLazy(inst._zod, "pattern", () => {
+		if (def.options.every((o) => o._zod.pattern)) {
+			const patterns = def.options.map((o) => o._zod.pattern);
+			return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
+		}
+	});
+	const single = def.options.length === 1;
+	const first = def.options[0]._zod.run;
+	inst._zod.parse = (payload, ctx) => {
+		if (single) return first(payload, ctx);
+		let async = false;
+		const results = [];
+		for (const option of def.options) {
+			const result = option._zod.run({
+				value: payload.value,
+				issues: []
+			}, ctx);
+			if (result instanceof Promise) {
+				results.push(result);
+				async = true;
+			} else {
+				if (result.issues.length === 0) return result;
+				results.push(result);
+			}
+		}
+		if (!async) return handleUnionResults(results, payload, inst, ctx);
+		return Promise.all(results).then((results) => {
+			return handleUnionResults(results, payload, inst, ctx);
+		});
+	};
+});
+const $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
+	def.inclusive = false;
+	$ZodUnion.init(inst, def);
+	const _super = inst._zod.parse;
+	defineLazy(inst._zod, "propValues", () => {
+		const propValues = {};
+		for (const option of def.options) {
+			const pv = option._zod.propValues;
+			if (!pv || Object.keys(pv).length === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+			for (const [k, v] of Object.entries(pv)) {
+				if (!propValues[k]) propValues[k] = /* @__PURE__ */ new Set();
+				for (const val of v) propValues[k].add(val);
+			}
+		}
+		return propValues;
+	});
+	const disc = cached(() => {
+		const opts = def.options;
+		const map = /* @__PURE__ */ new Map();
+		for (const o of opts) {
+			const values = o._zod.propValues?.[def.discriminator];
+			if (!values || values.size === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
+			for (const v of values) {
+				if (map.has(v)) throw new Error(`Duplicate discriminator value "${String(v)}"`);
+				map.set(v, o);
+			}
+		}
+		return map;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isObject(input)) {
+			payload.issues.push({
+				code: "invalid_type",
+				expected: "object",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const opt = disc.value.get(input?.[def.discriminator]);
+		if (opt) return opt._zod.run(payload, ctx);
+		if (def.unionFallback) return _super(payload, ctx);
+		payload.issues.push({
+			code: "invalid_union",
+			errors: [],
+			note: "No matching discriminator",
+			discriminator: def.discriminator,
+			input,
+			path: [def.discriminator],
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		const values = def.keyType._zod.values;
+		if (values) {
+			payload.value = {};
+			const recordKeys = /* @__PURE__ */ new Set();
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				recordKeys.add(typeof key === "number" ? key.toString() : key);
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result) => {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!recordKeys.has(key)) {
+				unrecognized = unrecognized ?? [];
+				unrecognized.push(key);
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized
+			});
+		} else {
+			payload.value = {};
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				let keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (typeof key === "string" && number$2.test(key) && keyResult.issues.length) {
+					const retryResult = def.keyType._zod.run({
+						value: Number(key),
+						issues: []
+					}, ctx);
+					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+					if (retryResult.issues.length === 0) keyResult = retryResult;
+				}
+				if (keyResult.issues.length) {
+					if (def.mode === "loose") payload.value[key] = input[key];
+					else payload.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result) => {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
+const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+	$ZodType.init(inst, def);
+	const values = getEnumValues(def.entries);
+	const valuesSet = new Set(values);
+	inst._zod.values = valuesSet;
+	inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (valuesSet.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
+	$ZodType.init(inst, def);
+	if (def.values.length === 0) throw new Error("Cannot create literal schema with no valid values");
+	const values = new Set(def.values);
+	inst._zod.values = values;
+	inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (values.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values: def.values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		if (ctx.direction === "backward") throw new $ZodEncodeError(inst.constructor.name);
+		const _out = def.transform(payload.value, payload);
+		if (ctx.async) return (_out instanceof Promise ? _out : Promise.resolve(_out)).then((output) => {
+			payload.value = output;
+			return payload;
+		});
+		if (_out instanceof Promise) throw new $ZodAsyncError();
+		payload.value = _out;
+		return payload;
+	};
+});
+function handleOptionalResult(result, input) {
+	if (result.issues.length && input === void 0) return {
+		issues: [],
+		value: void 0
+	};
+	return result;
+}
+const $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.optin = "optional";
+	inst._zod.optout = "optional";
+	defineLazy(inst._zod, "values", () => {
+		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, void 0]) : void 0;
+	});
+	defineLazy(inst._zod, "pattern", () => {
+		const pattern = def.innerType._zod.pattern;
+		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		if (def.innerType._zod.optin === "optional") {
+			const result = def.innerType._zod.run(payload, ctx);
+			if (result instanceof Promise) return result.then((r) => handleOptionalResult(r, payload.value));
+			return handleOptionalResult(result, payload.value);
+		}
+		if (payload.value === void 0) return payload;
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+const $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+	defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+	defineLazy(inst._zod, "pattern", () => {
+		const pattern = def.innerType._zod.pattern;
+		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
+	});
+	defineLazy(inst._zod, "values", () => {
+		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		if (payload.value === null) return payload;
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+const $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "values", () => def.in._zod.values);
+	defineLazy(inst._zod, "optin", () => def.in._zod.optin);
+	defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+	defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
+	inst._zod.parse = (payload, ctx) => {
+		if (ctx.direction === "backward") {
+			const right = def.out._zod.run(payload, ctx);
+			if (right instanceof Promise) return right.then((right) => handlePipeResult(right, def.in, ctx));
+			return handlePipeResult(right, def.in, ctx);
+		}
+		const left = def.in._zod.run(payload, ctx);
+		if (left instanceof Promise) return left.then((left) => handlePipeResult(left, def.out, ctx));
+		return handlePipeResult(left, def.out, ctx);
+	};
+});
+function handlePipeResult(left, next, ctx) {
+	if (left.issues.length) {
+		left.aborted = true;
+		return left;
+	}
+	return next._zod.run({
+		value: left.value,
+		issues: left.issues
+	}, ctx);
+}
+const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _) => {
+		return payload;
+	};
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		const r = def.fn(input);
+		if (r instanceof Promise) return r.then((r) => handleRefineResult(r, payload, input, inst));
+		handleRefineResult(r, payload, input, inst);
+	};
+});
+function handleRefineResult(result, payload, input, inst) {
+	if (!result) {
+		const _iss = {
+			code: "custom",
+			input,
+			inst,
+			path: [...inst._zod.def.path ?? []],
+			continue: !inst._zod.def.abort
+		};
+		if (inst._zod.def.params) _iss.params = inst._zod.def.params;
+		payload.issues.push(issue(_iss));
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/registries.js
+var _a;
+var $ZodRegistry = class {
+	constructor() {
+		this._map = /* @__PURE__ */ new WeakMap();
+		this._idmap = /* @__PURE__ */ new Map();
+	}
+	add(schema, ..._meta) {
+		const meta = _meta[0];
+		this._map.set(schema, meta);
+		if (meta && typeof meta === "object" && "id" in meta) this._idmap.set(meta.id, schema);
+		return this;
+	}
+	clear() {
+		this._map = /* @__PURE__ */ new WeakMap();
+		this._idmap = /* @__PURE__ */ new Map();
+		return this;
+	}
+	remove(schema) {
+		const meta = this._map.get(schema);
+		if (meta && typeof meta === "object" && "id" in meta) this._idmap.delete(meta.id);
+		this._map.delete(schema);
+		return this;
+	}
+	get(schema) {
+		const p = schema._zod.parent;
+		if (p) {
+			const pm = { ...this.get(p) ?? {} };
+			delete pm.id;
+			const f = {
+				...pm,
+				...this._map.get(schema)
+			};
+			return Object.keys(f).length ? f : void 0;
+		}
+		return this._map.get(schema);
+	}
+	has(schema) {
+		return this._map.has(schema);
+	}
+};
+function registry() {
+	return new $ZodRegistry();
+}
+(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
+globalThis.__zod_globalRegistry;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/api.js
+/* @__NO_SIDE_EFFECTS__ */
+function _string(Class, params) {
+	return new Class({
+		type: "string",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _number(Class, params) {
+	return new Class({
+		type: "number",
+		checks: [],
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _boolean(Class, params) {
+	return new Class({
+		type: "boolean",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _any(Class) {
+	return new Class({ type: "any" });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _unknown(Class) {
+	return new Class({ type: "unknown" });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _void$1(Class, params) {
+	return new Class({
+		type: "void",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _minLength(minimum, params) {
+	return new $ZodCheckMinLength({
+		check: "min_length",
+		...normalizeParams(params),
+		minimum
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _regex(pattern, params) {
+	return new $ZodCheckRegex({
+		check: "string_format",
+		format: "regex",
+		...normalizeParams(params),
+		pattern
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _custom(Class, fn, _params) {
+	const norm = normalizeParams(_params);
+	norm.abort ?? (norm.abort = true);
+	return new Class({
+		type: "custom",
+		check: "custom",
+		fn,
+		...norm
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/mini/schemas.js
+const ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+	if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");
+	$ZodType.init(inst, def);
+	inst.def = def;
+	inst.type = def.type;
+	inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
+	inst.safeParse = (data, params) => safeParse(inst, data, params);
+	inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+	inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+	inst.check = (...checks) => {
+		return inst.clone({
+			...def,
+			checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
+				check: ch,
+				def: { check: "custom" },
+				onattach: []
+			} } : ch)]
+		}, { parent: true });
+	};
+	inst.with = inst.check;
+	inst.clone = (_def, params) => clone(inst, _def, params);
+	inst.brand = () => inst;
+	inst.register = ((reg, meta) => {
+		reg.add(inst, meta);
+		return inst;
+	});
+	inst.apply = (fn) => fn(inst);
+});
+const ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
+	$ZodString.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function string(params) {
+	return /* @__PURE__ */ _string(ZodMiniString, params);
+}
+const ZodMiniNumber = /* @__PURE__ */ $constructor("ZodMiniNumber", (inst, def) => {
+	$ZodNumber.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function number$1(params) {
+	return /* @__PURE__ */ _number(ZodMiniNumber, params);
+}
+const ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def) => {
+	$ZodBoolean.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function boolean(params) {
+	return /* @__PURE__ */ _boolean(ZodMiniBoolean, params);
+}
+const ZodMiniAny = /* @__PURE__ */ $constructor("ZodMiniAny", (inst, def) => {
+	$ZodAny.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function any() {
+	return /* @__PURE__ */ _any(ZodMiniAny);
+}
+const ZodMiniUnknown = /* @__PURE__ */ $constructor("ZodMiniUnknown", (inst, def) => {
+	$ZodUnknown.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function unknown() {
+	return /* @__PURE__ */ _unknown(ZodMiniUnknown);
+}
+const ZodMiniVoid = /* @__PURE__ */ $constructor("ZodMiniVoid", (inst, def) => {
+	$ZodVoid.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function _void(params) {
+	return /* @__PURE__ */ _void$1(ZodMiniVoid, params);
+}
+const ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
+	$ZodArray.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function array(element, params) {
+	return new ZodMiniArray({
+		type: "array",
+		element,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
+	$ZodObject.init(inst, def);
+	ZodMiniType.init(inst, def);
+	defineLazy(inst, "shape", () => def.shape);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function object(shape, params) {
+	return new ZodMiniObject({
+		type: "object",
+		shape: shape ?? {},
+		...normalizeParams(params)
+	});
+}
+const ZodMiniUnion = /* @__PURE__ */ $constructor("ZodMiniUnion", (inst, def) => {
+	$ZodUnion.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function union(options, params) {
+	return new ZodMiniUnion({
+		type: "union",
+		options,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodMiniDiscriminatedUnion", (inst, def) => {
+	$ZodDiscriminatedUnion.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function discriminatedUnion(discriminator, options, params) {
+	return new ZodMiniDiscriminatedUnion({
+		type: "union",
+		options,
+		discriminator,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniRecord = /* @__PURE__ */ $constructor("ZodMiniRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function record(keyType, valueType, params) {
+	return new ZodMiniRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniEnum = /* @__PURE__ */ $constructor("ZodMiniEnum", (inst, def) => {
+	$ZodEnum.init(inst, def);
+	ZodMiniType.init(inst, def);
+	inst.options = Object.values(def.entries);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function _enum(values, params) {
+	return new ZodMiniEnum({
+		type: "enum",
+		entries: Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniLiteral = /* @__PURE__ */ $constructor("ZodMiniLiteral", (inst, def) => {
+	$ZodLiteral.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function literal(value, params) {
+	return new ZodMiniLiteral({
+		type: "literal",
+		values: Array.isArray(value) ? value : [value],
+		...normalizeParams(params)
+	});
+}
+const ZodMiniTransform = /* @__PURE__ */ $constructor("ZodMiniTransform", (inst, def) => {
+	$ZodTransform.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function transform(fn) {
+	return new ZodMiniTransform({
+		type: "transform",
+		transform: fn
+	});
+}
+const ZodMiniOptional = /* @__PURE__ */ $constructor("ZodMiniOptional", (inst, def) => {
+	$ZodOptional.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function optional(innerType) {
+	return new ZodMiniOptional({
+		type: "optional",
+		innerType
+	});
+}
+const ZodMiniNullable = /* @__PURE__ */ $constructor("ZodMiniNullable", (inst, def) => {
+	$ZodNullable.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function nullable(innerType) {
+	return new ZodMiniNullable({
+		type: "nullable",
+		innerType
+	});
+}
+const ZodMiniPipe = /* @__PURE__ */ $constructor("ZodMiniPipe", (inst, def) => {
+	$ZodPipe.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function pipe(in_, out) {
+	return new ZodMiniPipe({
+		type: "pipe",
+		in: in_,
+		out
+	});
+}
+const ZodMiniCustom = /* @__PURE__ */ $constructor("ZodMiniCustom", (inst, def) => {
+	$ZodCustom.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function custom(fn, _params) {
+	return /* @__PURE__ */ _custom(ZodMiniCustom, fn ?? (() => true), _params);
+}
+//#endregion
 //#region ../pieces-framework/dist/markdown-property-Df2l6_y_.js
-const BasePropertySchema = z.object({
-	displayName: z.string(),
-	description: z.optional(z.string()),
-	advanced: z.optional(z.boolean()),
-	width: z.optional(z.enum(["half", "full"])),
-	icon: z.optional(z.string()),
-	placeholder: z.optional(z.string())
-});
-const TPropertyValue = (_T, propertyType) => z.object({
-	type: z.literal(propertyType),
-	required: z.boolean(),
-	defaultValue: z.optional(z.any())
+const BasePropertySchema = /* @__PURE__ */ object({
+	displayName: /* @__PURE__ */ string(),
+	description: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	advanced: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	width: /* @__PURE__ */ optional(/* @__PURE__ */ _enum(["half", "full"])),
+	icon: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	placeholder: /* @__PURE__ */ optional(/* @__PURE__ */ string())
+});
+const TPropertyValue = (_T, propertyType) => /* @__PURE__ */ object({
+	type: /* @__PURE__ */ literal(propertyType),
+	required: /* @__PURE__ */ boolean(),
+	defaultValue: /* @__PURE__ */ optional(/* @__PURE__ */ any())
 });
 let PropertyType = /* @__PURE__ */ function(PropertyType) {
 	PropertyType["SHORT_TEXT"] = "SHORT_TEXT";
@@ -41,72 +1405,70 @@ let PropertyType = /* @__PURE__ */ function(PropertyType) {
 	PropertyType["COLOR"] = "COLOR";
 	return PropertyType;
 }({});
-const ShortTextProperty = z.object({
+const ShortTextProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	...TPropertyValue(z.string(), PropertyType.SHORT_TEXT).shape
+	...TPropertyValue(/* @__PURE__ */ string(), PropertyType.SHORT_TEXT).shape
 });
-const LongTextProperty = z.object({
+const LongTextProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	...TPropertyValue(z.string(), PropertyType.LONG_TEXT).shape
-});
-const DropdownOption = z.object({
-	label: z.string(),
-	value: z.unknown(),
-	description: z.optional(z.string()),
-	icon: z.optional(z.string())
-});
-const DropdownState = z.object({
-	disabled: z.optional(z.boolean()),
-	placeholder: z.optional(z.string()),
-	options: z.array(DropdownOption)
+	...TPropertyValue(/* @__PURE__ */ string(), PropertyType.LONG_TEXT).shape
+});
+const DropdownState = /* @__PURE__ */ object({
+	disabled: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	placeholder: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	options: /* @__PURE__ */ array(/* @__PURE__ */ object({
+		label: /* @__PURE__ */ string(),
+		value: /* @__PURE__ */ unknown(),
+		description: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+		icon: /* @__PURE__ */ optional(/* @__PURE__ */ string())
+	}))
 });
-const StaticDropdownDisplay = z.enum(["cards"]);
-const StaticDropdownProperty = z.object({
+const StaticDropdownDisplay = /* @__PURE__ */ _enum(["cards"]);
+const StaticDropdownProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
 	options: DropdownState,
-	display: z.optional(StaticDropdownDisplay),
-	...TPropertyValue(z.unknown(), PropertyType.STATIC_DROPDOWN).shape
+	display: /* @__PURE__ */ optional(StaticDropdownDisplay),
+	...TPropertyValue(/* @__PURE__ */ unknown(), PropertyType.STATIC_DROPDOWN).shape
 });
-const StaticMultiSelectDropdownProperty = z.object({
+const StaticMultiSelectDropdownProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
 	options: DropdownState,
-	...TPropertyValue(z.array(z.unknown()), PropertyType.STATIC_MULTI_SELECT_DROPDOWN).shape
+	...TPropertyValue(/* @__PURE__ */ array(/* @__PURE__ */ unknown()), PropertyType.STATIC_MULTI_SELECT_DROPDOWN).shape
 });
-const CheckboxProperty = z.object({
+const CheckboxProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	reveals: z.optional(z.array(z.string())),
-	...TPropertyValue(z.boolean(), PropertyType.CHECKBOX).shape
+	reveals: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
+	...TPropertyValue(/* @__PURE__ */ boolean(), PropertyType.CHECKBOX).shape
 });
-const NumberProperty = z.object({
+const NumberProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	display: z.optional(z.enum(["stepper"])),
-	min: z.optional(z.number()),
-	max: z.optional(z.number()),
-	step: z.optional(z.number()),
-	...TPropertyValue(z.number(), PropertyType.NUMBER).shape
+	display: /* @__PURE__ */ optional(/* @__PURE__ */ _enum(["stepper"])),
+	min: /* @__PURE__ */ optional(/* @__PURE__ */ number$1()),
+	max: /* @__PURE__ */ optional(/* @__PURE__ */ number$1()),
+	step: /* @__PURE__ */ optional(/* @__PURE__ */ number$1()),
+	...TPropertyValue(/* @__PURE__ */ number$1(), PropertyType.NUMBER).shape
 });
-const FileProperty = z.object({
+const FileProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	streaming: z.optional(z.boolean()),
-	...TPropertyValue(z.unknown(), PropertyType.FILE).shape
-});
-const DateRangePreset = z.enum([
-	"any_time",
-	"last_24_hours",
-	"last_7_days",
-	"last_30_days",
-	"last_90_days",
-	"this_month",
-	"custom"
-]);
-const DateRangeValue = z.object({
-	preset: z.optional(DateRangePreset),
-	after: z.optional(z.string()),
-	before: z.optional(z.string())
+	streaming: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	...TPropertyValue(/* @__PURE__ */ unknown(), PropertyType.FILE).shape
+});
+const DateRangeValue = /* @__PURE__ */ object({
+	preset: /* @__PURE__ */ optional(/* @__PURE__ */ _enum([
+		"any_time",
+		"last_24_hours",
+		"last_7_days",
+		"last_30_days",
+		"last_90_days",
+		"this_month",
+		"custom"
+	])),
+	after: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	before: /* @__PURE__ */ optional(/* @__PURE__ */ string())
 });
-const DateRangeProperty = z.object({
+const DateRangeProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	display: z.optional(z.enum(["dropdown"])),
+	display: /* @__PURE__ */ optional(/* @__PURE__ */ _enum(["dropdown"])),
 	...TPropertyValue(DateRangeValue, PropertyType.DATE_RANGE).shape
 });
 let MarkdownVariant = /* @__PURE__ */ function(MarkdownVariant) {
@@ -119,21 +1481,21 @@ let MarkdownVariant = /* @__PURE__ */ function(MarkdownVariant) {
 function isNil(value) {
 	return value === null || value === void 0;
 }
-const MarkDownProperty = z.object({
+const MarkDownProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	...TPropertyValue(z.void(), PropertyType.MARKDOWN).shape,
-	variant: z.optional(z.enum(MarkdownVariant))
+	...TPropertyValue(/* @__PURE__ */ _void(), PropertyType.MARKDOWN).shape,
+	variant: /* @__PURE__ */ optional(/* @__PURE__ */ _enum(MarkdownVariant))
 });
 //#endregion
 //#region ../pieces-framework/dist/input-COuhC1I-.js
-const ErrorHandlingOptionsParam = z.object({
-	retryOnFailure: z.object({
-		defaultValue: z.optional(z.boolean()),
-		hide: z.optional(z.boolean())
+const ErrorHandlingOptionsParam = /* @__PURE__ */ object({
+	retryOnFailure: /* @__PURE__ */ object({
+		defaultValue: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		hide: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
 	}),
-	continueOnFailure: z.object({
-		defaultValue: z.optional(z.boolean()),
-		hide: z.optional(z.boolean())
+	continueOnFailure: /* @__PURE__ */ object({
+		defaultValue: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		hide: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
 	})
 });
 var IAction = class {
@@ -159,29 +1521,29 @@ const createAction = (params) => {
 		retryOnFailure: { defaultValue: false }
 	}, params.outputSchema, params.audience, params.aiMetadata, params.classification);
 };
-const DropdownProperty = z.object({
+const DropdownProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	...TPropertyValue(z.unknown(), PropertyType.DROPDOWN).shape,
-	refreshers: z.array(z.string())
+	...TPropertyValue(/* @__PURE__ */ unknown(), PropertyType.DROPDOWN).shape,
+	refreshers: /* @__PURE__ */ array(/* @__PURE__ */ string())
 });
-const MultiSelectDropdownProperty = z.object({
+const MultiSelectDropdownProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	...TPropertyValue(z.array(z.unknown()), PropertyType.MULTI_SELECT_DROPDOWN).shape,
-	refreshers: z.array(z.string())
+	...TPropertyValue(/* @__PURE__ */ array(/* @__PURE__ */ unknown()), PropertyType.MULTI_SELECT_DROPDOWN).shape,
+	refreshers: /* @__PURE__ */ array(/* @__PURE__ */ string())
 });
-const JsonProperty = z.object({
+const JsonProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	...TPropertyValue(z.union([z.record(z.string(), z.unknown())]), PropertyType.JSON).shape
+	...TPropertyValue(/* @__PURE__ */ union([/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ unknown())]), PropertyType.JSON).shape
 });
-const ColorProperty = z.object({
+const ColorProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	...TPropertyValue(z.string(), PropertyType.COLOR).shape
+	...TPropertyValue(/* @__PURE__ */ string(), PropertyType.COLOR).shape
 });
-const DateTimeProperty = z.object({
+const DateTimeProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	...TPropertyValue(z.string(), PropertyType.DATE_TIME).shape
+	...TPropertyValue(/* @__PURE__ */ string(), PropertyType.DATE_TIME).shape
 });
-const ArraySubProps = z.record(z.string(), z.union([
+const ArraySubProps = /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ union([
 	ShortTextProperty,
 	LongTextProperty,
 	StaticDropdownProperty,
@@ -194,42 +1556,28 @@ const ArraySubProps = z.record(z.string(), z.union([
 	ColorProperty,
 	DateTimeProperty
 ]));
-const ArrayProperty = z.object({
+const ArrayProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	properties: z.optional(ArraySubProps),
-	...TPropertyValue(z.array(z.unknown()), PropertyType.ARRAY).shape
+	properties: /* @__PURE__ */ optional(ArraySubProps),
+	...TPropertyValue(/* @__PURE__ */ array(/* @__PURE__ */ unknown()), PropertyType.ARRAY).shape
 });
-const DynamicProp = z.union([
-	ShortTextProperty,
-	StaticDropdownProperty,
-	JsonProperty,
-	ArrayProperty,
-	StaticMultiSelectDropdownProperty
-]);
-z.record(z.string(), DynamicProp);
-const DynamicProperties = z.object({
-	refreshers: z.array(z.string()),
-	...BasePropertySchema.shape,
-	...TPropertyValue(z.unknown(), PropertyType.DYNAMIC).shape
-});
-const ObjectProperty = z.object({
-	...BasePropertySchema.shape,
-	...TPropertyValue(z.record(z.string(), z.unknown()), PropertyType.OBJECT).shape
-});
-const RichTextProperty = z.object({
+const DynamicProperties = /* @__PURE__ */ object({
+	refreshers: /* @__PURE__ */ array(/* @__PURE__ */ string()),
 	...BasePropertySchema.shape,
-	formatProperty: z.optional(z.string()),
-	...TPropertyValue(z.string(), PropertyType.RICH_TEXT).shape
+	...TPropertyValue(/* @__PURE__ */ unknown(), PropertyType.DYNAMIC).shape
 });
-const CustomProperty = z.object({
+const ObjectProperty = /* @__PURE__ */ object({
 	...BasePropertySchema.shape,
-	...TPropertyValue(z.unknown(), PropertyType.CUSTOM).shape,
-	code: z.string()
+	...TPropertyValue(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ unknown()), PropertyType.OBJECT).shape
 });
-const InputProperty = z.union([
+const InputProperty = /* @__PURE__ */ union([
 	ShortTextProperty,
 	LongTextProperty,
-	RichTextProperty,
+	/* @__PURE__ */ object({
+		...BasePropertySchema.shape,
+		formatProperty: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+		...TPropertyValue(/* @__PURE__ */ string(), PropertyType.RICH_TEXT).shape
+	}),
 	MarkDownProperty,
 	CheckboxProperty,
 	StaticDropdownProperty,
@@ -244,7 +1592,11 @@ const InputProperty = z.union([
 	DateTimeProperty,
 	DateRangeProperty,
 	FileProperty,
-	CustomProperty,
+	/* @__PURE__ */ object({
+		...BasePropertySchema.shape,
+		...TPropertyValue(/* @__PURE__ */ unknown(), PropertyType.CUSTOM).shape,
+		code: /* @__PURE__ */ string()
+	}),
 	ColorProperty
 ]);
 const Property = {
@@ -421,41 +1773,37 @@ let WebhookHandshakeStrategy = /* @__PURE__ */ function(WebhookHandshakeStrategy
 	WebhookHandshakeStrategy["HEAD_REQUEST"] = "HEAD_REQUEST";
 	return WebhookHandshakeStrategy;
 }({});
-z.object({
-	strategy: z.enum(WebhookHandshakeStrategy),
-	paramName: z.optional(z.string())
-});
 let TriggerTestStrategy = /* @__PURE__ */ function(TriggerTestStrategy) {
 	TriggerTestStrategy["SIMULATION"] = "SIMULATION";
 	TriggerTestStrategy["TEST_FUNCTION"] = "TEST_FUNCTION";
 	return TriggerTestStrategy;
 }({});
-const BasePieceAuthSchema = z.object({
-	displayName: z.string(),
-	description: z.optional(z.string()),
-	hasConnectionIdentifier: z.optional(z.boolean())
+const BasePieceAuthSchema = /* @__PURE__ */ object({
+	displayName: /* @__PURE__ */ string(),
+	description: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	hasConnectionIdentifier: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
 });
-const BasicAuthPropertyValue = z.object({
-	username: z.string(),
-	password: z.string()
+const BasicAuthPropertyValue = /* @__PURE__ */ object({
+	username: /* @__PURE__ */ string(),
+	password: /* @__PURE__ */ string()
 });
-const BasicAuthProperty = z.object({
+const BasicAuthProperty = /* @__PURE__ */ object({
 	...BasePieceAuthSchema.shape,
-	username: z.object({
-		displayName: z.string(),
-		description: z.optional(z.string())
+	username: /* @__PURE__ */ object({
+		displayName: /* @__PURE__ */ string(),
+		description: /* @__PURE__ */ optional(/* @__PURE__ */ string())
 	}),
-	password: z.object({
-		displayName: z.string(),
-		description: z.optional(z.string())
+	password: /* @__PURE__ */ object({
+		displayName: /* @__PURE__ */ string(),
+		description: /* @__PURE__ */ optional(/* @__PURE__ */ string())
 	}),
 	...TPropertyValue(BasicAuthPropertyValue, PropertyType.BASIC_AUTH).shape
 });
-const SecretTextProperty = z.object({
+const SecretTextProperty = /* @__PURE__ */ object({
 	...BasePieceAuthSchema.shape,
-	...TPropertyValue(z.object({ auth: z.string() }), PropertyType.SECRET_TEXT).shape
+	...TPropertyValue(/* @__PURE__ */ object({ auth: /* @__PURE__ */ string() }), PropertyType.SECRET_TEXT).shape
 });
-const CustomAuthProps = z.record(z.string(), z.union([
+const CustomAuthProps = /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ union([
 	ShortTextProperty,
 	LongTextProperty,
 	SecretTextProperty,
@@ -465,12 +1813,12 @@ const CustomAuthProps = z.record(z.string(), z.union([
 	MarkDownProperty,
 	StaticMultiSelectDropdownProperty
 ]));
-const CustomAuthProperty = z.object({
+const CustomAuthProperty = /* @__PURE__ */ object({
 	...BasePieceAuthSchema.shape,
 	props: CustomAuthProps,
-	...TPropertyValue(z.unknown(), PropertyType.CUSTOM_AUTH).shape
+	...TPropertyValue(/* @__PURE__ */ unknown(), PropertyType.CUSTOM_AUTH).shape
 });
-const OIDCAuthProps = z.record(z.string(), z.union([
+const OIDCAuthProps = /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ union([
 	ShortTextProperty,
 	LongTextProperty,
 	SecretTextProperty,
@@ -480,54 +1828,53 @@ const OIDCAuthProps = z.record(z.string(), z.union([
 	StaticMultiSelectDropdownProperty,
 	MarkDownProperty
 ]));
-const OIDCProperty = z.object({
+const OIDCProperty = /* @__PURE__ */ object({
 	...BasePieceAuthSchema.shape,
 	props: OIDCAuthProps,
-	...TPropertyValue(z.unknown(), PropertyType.OIDC).shape
+	...TPropertyValue(/* @__PURE__ */ unknown(), PropertyType.OIDC).shape
 });
 let OAuth2AuthorizationMethod = /* @__PURE__ */ function(OAuth2AuthorizationMethod) {
 	OAuth2AuthorizationMethod["HEADER"] = "HEADER";
 	OAuth2AuthorizationMethod["BODY"] = "BODY";
 	return OAuth2AuthorizationMethod;
 }({});
-const OAuthProp = z.union([
+const OAuthProp = /* @__PURE__ */ union([
 	ShortTextProperty,
 	SecretTextProperty,
 	StaticDropdownProperty
 ]);
-const OAuth2Props = z.record(z.string(), OAuthProp);
-const OAuth2ExtraProps = z.object({
-	props: z.optional(z.record(z.string(), OAuthProp)),
-	authUrl: z.string(),
-	tokenUrl: z.string(),
-	scope: z.array(z.string()),
-	prompt: z.optional(z.union([
-		z.literal("none"),
-		z.literal("consent"),
-		z.literal("login"),
-		z.literal("omit")
+const OAuth2Props = /* @__PURE__ */ record(/* @__PURE__ */ string(), OAuthProp);
+const OAuth2ExtraProps = /* @__PURE__ */ object({
+	props: /* @__PURE__ */ optional(/* @__PURE__ */ record(/* @__PURE__ */ string(), OAuthProp)),
+	authUrl: /* @__PURE__ */ string(),
+	tokenUrl: /* @__PURE__ */ string(),
+	scope: /* @__PURE__ */ array(/* @__PURE__ */ string()),
+	prompt: /* @__PURE__ */ optional(/* @__PURE__ */ union([
+		/* @__PURE__ */ literal("none"),
+		/* @__PURE__ */ literal("consent"),
+		/* @__PURE__ */ literal("login"),
+		/* @__PURE__ */ literal("omit")
 	])),
-	pkce: z.optional(z.boolean()),
-	pkceMethod: z.optional(z.union([z.literal("plain"), z.literal("S256")])),
-	authorizationMethod: z.optional(z.enum(OAuth2AuthorizationMethod)),
-	grantType: z.optional(z.union([z.enum(OAuth2GrantType), z.literal(BOTH_CLIENT_CREDENTIALS_AND_AUTHORIZATION_CODE)])),
-	extra: z.optional(z.record(z.string(), z.string()))
-});
-const OAuth2PropertyValue = z.object({
-	access_token: z.string(),
-	props: z.optional(OAuth2Props),
-	data: z.record(z.string(), z.any())
-});
-const OAuth2Property = z.object({
-	...BasePieceAuthSchema.shape,
-	...OAuth2ExtraProps.shape,
-	...TPropertyValue(OAuth2PropertyValue, PropertyType.OAUTH2).shape
-});
-const PieceAuthProperty = z.union([
+	pkce: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	pkceMethod: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ literal("plain"), /* @__PURE__ */ literal("S256")])),
+	authorizationMethod: /* @__PURE__ */ optional(/* @__PURE__ */ _enum(OAuth2AuthorizationMethod)),
+	grantType: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ _enum(OAuth2GrantType), /* @__PURE__ */ literal(BOTH_CLIENT_CREDENTIALS_AND_AUTHORIZATION_CODE)])),
+	extra: /* @__PURE__ */ optional(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ string()))
+});
+const OAuth2PropertyValue = /* @__PURE__ */ object({
+	access_token: /* @__PURE__ */ string(),
+	props: /* @__PURE__ */ optional(OAuth2Props),
+	data: /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ any())
+});
+const PieceAuthProperty = /* @__PURE__ */ union([
 	BasicAuthProperty,
 	CustomAuthProperty,
 	OIDCProperty,
-	OAuth2Property,
+	/* @__PURE__ */ object({
+		...BasePieceAuthSchema.shape,
+		...OAuth2ExtraProps.shape,
+		...TPropertyValue(OAuth2PropertyValue, PropertyType.OAUTH2).shape
+	}),
 	SecretTextProperty
 ]);
 AppConnectionType.OAUTH2, PropertyType.OAUTH2, AppConnectionType.CLOUD_OAUTH2, PropertyType.OAUTH2, AppConnectionType.PLATFORM_OAUTH2, PropertyType.OAUTH2, AppConnectionType.BASIC_AUTH, PropertyType.BASIC_AUTH, AppConnectionType.CUSTOM_AUTH, PropertyType.CUSTOM_AUTH, AppConnectionType.OIDC, PropertyType.OIDC, AppConnectionType.SECRET_TEXT, PropertyType.SECRET_TEXT, AppConnectionType.NO_AUTH;
@@ -610,48 +1957,23 @@ let PauseType = /* @__PURE__ */ function(PauseType) {
 	PauseType["WEBHOOK"] = "WEBHOOK";
 	return PauseType;
 }({});
-let StreamStepProgress = /* @__PURE__ */ function(StreamStepProgress) {
-	StreamStepProgress["WEBSOCKET"] = "WEBSOCKET";
-	StreamStepProgress["NONE"] = "NONE";
-	return StreamStepProgress;
-}({});
-const RespondResponse = z.object({
-	status: z.optional(z.number()),
-	body: z.optional(z.unknown()),
-	headers: z.optional(z.record(z.string(), z.string()))
-});
-const DelayPauseMetadata = z.object({
-	type: z.literal(PauseType.DELAY),
-	resumeDateTime: z.string(),
-	requestIdToReply: z.optional(z.string()),
-	handlerId: z.optional(z.string()),
-	streamStepProgress: z.optional(z.enum(StreamStepProgress))
-});
-const WebhookPauseMetadata = z.object({
-	type: z.literal(PauseType.WEBHOOK),
-	requestId: z.string(),
-	requestIdToReply: z.optional(z.string()),
-	response: RespondResponse,
-	handlerId: z.optional(z.string()),
-	streamStepProgress: z.optional(z.enum(StreamStepProgress))
-});
-z.union([DelayPauseMetadata, WebhookPauseMetadata]);
+PauseType.DELAY;
+PauseType.WEBHOOK;
 const ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 const ID_LENGTH = 21;
-z.string().check(z.regex(new RegExp(`^[0-9a-zA-Z]{${ID_LENGTH}}$`)));
+(/* @__PURE__ */ string()).check(/* @__PURE__ */ _regex(new RegExp(`^[0-9a-zA-Z]{${ID_LENGTH}}$`)));
 customAlphabet(ALPHABET, ID_LENGTH);
-const DateOrString = z.pipe(z.transform((val) => val instanceof Date ? val.toISOString() : val), z.string());
+const DateOrString = /* @__PURE__ */ pipe(/* @__PURE__ */ transform((val) => val instanceof Date ? val.toISOString() : val), /* @__PURE__ */ string());
 const BaseModelSchema = {
-	id: z.string(),
+	id: /* @__PURE__ */ string(),
 	created: DateOrString,
 	updated: DateOrString
 };
-const Nullable = (schema) => z.optional(z.nullable(schema));
+const Nullable = (schema) => /* @__PURE__ */ optional(/* @__PURE__ */ nullable(schema));
 function NullableEnum(enumObj) {
-	return z.optional(z.nullable(z.enum(enumObj)));
+	return /* @__PURE__ */ optional(/* @__PURE__ */ nullable(/* @__PURE__ */ _enum(enumObj)));
 }
-z.pipe(z.transform((val) => val === "true" || val === true ? true : val === "false" || val === false ? false : void 0), z.optional(z.boolean()));
-const OptionalArrayFromQuery = (schema) => z.pipe(z.transform((val) => Array.isArray(val) ? val : val !== void 0 ? [val] : void 0), z.optional(z.array(schema)));
+const OptionalArrayFromQuery = (schema) => /* @__PURE__ */ pipe(/* @__PURE__ */ transform((val) => Array.isArray(val) ? val : val !== void 0 ? [val] : void 0), /* @__PURE__ */ optional(/* @__PURE__ */ array(schema)));
 let AIProviderName = /* @__PURE__ */ function(AIProviderName) {
 	AIProviderName["OPENAI"] = "openai";
 	AIProviderName["OPENROUTER"] = "openrouter";
@@ -679,23 +2001,6 @@ let AgentToolType = /* @__PURE__ */ function(AgentToolType) {
 	AgentToolType["KNOWLEDGE_BASE"] = "KNOWLEDGE_BASE";
 	return AgentToolType;
 }({});
-let FieldControlMode = /* @__PURE__ */ function(FieldControlMode) {
-	FieldControlMode["AGENT_DECIDE"] = "agent-decide";
-	FieldControlMode["CHOOSE_YOURSELF"] = "choose-yourself";
-	FieldControlMode["LEAVE_EMPTY"] = "leave-empty";
-	return FieldControlMode;
-}({});
-let KnowledgeBaseSourceType = /* @__PURE__ */ function(KnowledgeBaseSourceType) {
-	KnowledgeBaseSourceType["FILE"] = "FILE";
-	KnowledgeBaseSourceType["TABLE"] = "TABLE";
-	return KnowledgeBaseSourceType;
-}({});
-let McpProtocol = /* @__PURE__ */ function(McpProtocol) {
-	McpProtocol["SSE"] = "sse";
-	McpProtocol["STREAMABLE_HTTP"] = "streamable-http";
-	McpProtocol["SIMPLE_HTTP"] = "http";
-	return McpProtocol;
-}({});
 let McpAuthType = /* @__PURE__ */ function(McpAuthType) {
 	McpAuthType["NONE"] = "none";
 	McpAuthType["ACCESS_TOKEN"] = "access_token";
@@ -703,12 +2008,6 @@ let McpAuthType = /* @__PURE__ */ function(McpAuthType) {
 	McpAuthType["HEADERS"] = "headers";
 	return McpAuthType;
 }({});
-let AgentOutputFieldType = /* @__PURE__ */ function(AgentOutputFieldType) {
-	AgentOutputFieldType["TEXT"] = "text";
-	AgentOutputFieldType["NUMBER"] = "number";
-	AgentOutputFieldType["BOOLEAN"] = "boolean";
-	return AgentOutputFieldType;
-}({});
 let ContentBlockType = /* @__PURE__ */ function(ContentBlockType) {
 	ContentBlockType["MARKDOWN"] = "MARKDOWN";
 	ContentBlockType["TOOL_CALL"] = "TOOL_CALL";
@@ -727,238 +2026,25 @@ let ToolCallType = /* @__PURE__ */ function(ToolCallType) {
 	ToolCallType["UNKNOWN"] = "UNKNOWN";
 	return ToolCallType;
 }({});
-const PredefinedInputField = z.object({
-	mode: z.enum(FieldControlMode),
-	value: z.unknown()
-});
-const PredefinedInputsStructure = z.object({
-	auth: z.optional(z.string()),
-	fields: z.record(z.string(), PredefinedInputField)
-});
-const AgentPieceToolMetadata = z.object({
-	pieceName: z.string(),
-	pieceVersion: z.string(),
-	actionName: z.string(),
-	predefinedInput: z.optional(PredefinedInputsStructure)
-});
-const AgentPieceTool = z.object({
-	type: z.literal(AgentToolType.PIECE),
-	toolName: z.string().check(z.minLength(1)),
-	pieceMetadata: AgentPieceToolMetadata
-});
-const McpAuthNone = z.object({ type: z.literal(McpAuthType.NONE) });
-const McpAuthAccessToken = z.object({
-	type: z.literal(McpAuthType.ACCESS_TOKEN),
-	accessToken: z.string()
-});
-const McpAuthApiKey = z.object({
-	type: z.literal(McpAuthType.API_KEY),
-	apiKey: z.string(),
-	apiKeyHeader: z.string()
-});
-const McpAuthHeaders = z.object({
-	type: z.literal(McpAuthType.HEADERS),
-	headers: z.record(z.string(), z.string())
-});
-const McpAuthConfig = z.discriminatedUnion("type", [
-	McpAuthNone,
-	McpAuthAccessToken,
-	McpAuthApiKey,
-	McpAuthHeaders
-]);
-const AgentFlowTool = z.object({
-	type: z.literal(AgentToolType.FLOW),
-	toolName: z.string().check(z.minLength(1)),
-	externalFlowId: z.string(),
-	flowDisplayName: z.optional(z.string())
-});
-const AgentMcpTool = z.object({
-	type: z.literal(AgentToolType.MCP),
-	toolName: z.string().check(z.minLength(1)),
-	serverUrl: z.url(),
-	protocol: z.enum(McpProtocol),
-	auth: McpAuthConfig
-});
-const AgentKnowledgeBaseTool = z.object({
-	type: z.literal(AgentToolType.KNOWLEDGE_BASE),
-	toolName: z.string().check(z.minLength(1)),
-	sourceType: z.enum(KnowledgeBaseSourceType),
-	sourceId: z.string(),
-	sourceName: z.string()
-});
-z.discriminatedUnion("type", [
-	AgentPieceTool,
-	AgentFlowTool,
-	AgentMcpTool,
-	AgentKnowledgeBaseTool
-]);
-z.object({
-	displayName: z.string(),
-	description: z.optional(z.string()),
-	type: z.enum(AgentOutputFieldType)
-});
-const MarkdownContentBlock = z.object({
-	type: z.literal(ContentBlockType.MARKDOWN),
-	markdown: z.string()
-});
+AgentToolType.PIECE, (/* @__PURE__ */ string()).check(/* @__PURE__ */ _minLength(1));
+McpAuthType.NONE, McpAuthType.ACCESS_TOKEN, McpAuthType.API_KEY, McpAuthType.HEADERS;
+AgentToolType.FLOW, (/* @__PURE__ */ string()).check(/* @__PURE__ */ _minLength(1)), AgentToolType.MCP, (/* @__PURE__ */ string()).check(/* @__PURE__ */ _minLength(1)), AgentToolType.KNOWLEDGE_BASE, (/* @__PURE__ */ string()).check(/* @__PURE__ */ _minLength(1));
+ContentBlockType.MARKDOWN;
 const toolCallBaseShape = {
-	type: z.literal(ContentBlockType.TOOL_CALL),
-	input: Nullable(z.record(z.string(), z.unknown())),
-	output: z.optional(z.unknown()),
-	toolName: z.string(),
-	status: z.enum(ToolCallStatus),
-	toolCallId: z.string(),
-	startTime: z.string(),
-	endTime: z.optional(z.string())
+	type: /* @__PURE__ */ literal(ContentBlockType.TOOL_CALL),
+	input: Nullable(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ unknown())),
+	output: /* @__PURE__ */ optional(/* @__PURE__ */ unknown()),
+	toolName: /* @__PURE__ */ string(),
+	status: /* @__PURE__ */ _enum(ToolCallStatus),
+	toolCallId: /* @__PURE__ */ string(),
+	startTime: /* @__PURE__ */ string(),
+	endTime: /* @__PURE__ */ optional(/* @__PURE__ */ string())
 };
-z.object(toolCallBaseShape);
-const ToolCallContentBlock = z.discriminatedUnion("toolCallType", [
-	z.object({
-		...toolCallBaseShape,
-		toolCallType: z.literal(ToolCallType.PIECE),
-		pieceName: z.string(),
-		pieceVersion: z.string(),
-		actionName: z.string()
-	}),
-	z.object({
-		...toolCallBaseShape,
-		toolCallType: z.literal(ToolCallType.FLOW),
-		displayName: z.string(),
-		externalFlowId: z.string()
-	}),
-	z.object({
-		...toolCallBaseShape,
-		toolCallType: z.literal(ToolCallType.MCP),
-		displayName: z.string(),
-		serverUrl: z.string()
-	}),
-	z.object({
-		...toolCallBaseShape,
-		toolCallType: z.literal(ToolCallType.KNOWLEDGE_BASE),
-		displayName: z.string(),
-		sourceType: z.string()
-	}),
-	z.object({
-		...toolCallBaseShape,
-		toolCallType: z.literal(ToolCallType.UNKNOWN),
-		displayName: z.string()
-	})
-]);
-z.union([MarkdownContentBlock, ToolCallContentBlock]);
-let AIProviderModelType = /* @__PURE__ */ function(AIProviderModelType) {
-	AIProviderModelType["IMAGE"] = "image";
-	AIProviderModelType["TEXT"] = "text";
-	return AIProviderModelType;
-}({});
-const BaseAIProviderAuthConfig = z.object({ apiKey: z.string() });
-const AnthropicProviderAuthConfig = BaseAIProviderAuthConfig;
-const ActivePiecesProviderAuthConfig = z.object({
-	apiKey: z.string(),
-	apiKeyHash: z.string()
-});
-const OpenAICompatibleProviderAuthConfig = BaseAIProviderAuthConfig;
-const CloudflareGatewayProviderAuthConfig = BaseAIProviderAuthConfig;
-const AzureProviderAuthConfig = BaseAIProviderAuthConfig;
-const GoogleProviderAuthConfig = BaseAIProviderAuthConfig;
-const OpenAIProviderAuthConfig = BaseAIProviderAuthConfig;
-const OpenRouterProviderAuthConfig = BaseAIProviderAuthConfig;
-const MistralProviderAuthConfig = BaseAIProviderAuthConfig;
-const VertexProviderAuthConfig = z.object({ serviceAccountJson: z.string().check(z.minLength(1)) });
-const BedrockProviderAuthConfig = z.object({
-	accessKeyId: z.string().check(z.minLength(1)),
-	secretAccessKey: z.string().check(z.minLength(1))
-});
-const AnthropicProviderConfig = z.object({});
-const ActivePiecesProviderConfig = z.object({});
-const GoogleProviderConfig = z.object({});
-const OpenAIProviderConfig = z.object({});
-const OpenRouterProviderConfig = z.object({});
-const MistralProviderConfig = z.object({});
-const ProviderModelConfig = z.object({
-	modelId: z.string(),
-	modelName: z.string(),
-	modelType: z.enum(AIProviderModelType)
-});
-const OpenAICompatibleProviderConfig = z.object({
-	apiKeyHeader: z.string(),
-	baseUrl: z.string(),
-	models: z.array(ProviderModelConfig),
-	defaultHeaders: z.optional(z.record(z.string(), z.string())),
-	apiStyle: z.optional(z.enum(["chat", "responses"]))
-});
-const CloudflareGatewayProviderConfig = z.object({
-	accountId: z.string(),
-	gatewayId: z.string(),
-	models: z.array(ProviderModelConfig),
-	vertexProject: z.optional(z.string()),
-	vertexRegion: z.optional(z.string())
-});
-const AzureProviderConfig = z.object({
-	resourceName: z.string(),
-	apiVersion: z.pipe(z.transform((v) => typeof v === "string" && v.trim().length === 0 ? void 0 : v), z.optional(z.string()))
-});
-const BedrockProviderConfig = z.object({ region: z.string().check(z.minLength(1)) });
-const VertexProviderConfig = z.object({
-	project: z.string().check(z.regex(/^[a-z0-9][a-z0-9-]{0,62}$/)),
-	region: z.string().check(z.regex(/^[a-z0-9][a-z0-9-]{0,62}$/)),
-	models: z.array(ProviderModelConfig)
-});
-const OpenAiCompatibleVendorConfig = z.object({});
-const AIProviderAuthConfig = z.union([
-	AnthropicProviderAuthConfig,
-	AzureProviderAuthConfig,
-	GoogleProviderAuthConfig,
-	OpenAIProviderAuthConfig,
-	OpenRouterProviderAuthConfig,
-	CloudflareGatewayProviderAuthConfig,
-	OpenAICompatibleProviderAuthConfig,
-	ActivePiecesProviderAuthConfig,
-	BedrockProviderAuthConfig,
-	VertexProviderAuthConfig,
-	MistralProviderAuthConfig
-]);
-const AIProviderConfig = z.union([
-	OpenAICompatibleProviderConfig,
-	CloudflareGatewayProviderConfig,
-	AzureProviderConfig,
-	VertexProviderConfig,
-	BedrockProviderConfig,
-	AnthropicProviderConfig,
-	GoogleProviderConfig,
-	OpenAIProviderConfig,
-	OpenRouterProviderConfig,
-	ActivePiecesProviderConfig,
-	MistralProviderConfig,
-	OpenAiCompatibleVendorConfig
-]);
-z.object({
-	id: z.string(),
-	name: z.string(),
-	type: z.enum(AIProviderModelType)
-});
-z.object({
-	id: z.string(),
-	name: z.string(),
-	provider: z.enum(AIProviderName),
-	config: AIProviderConfig,
-	enabledForChat: z.boolean()
-});
-z.object({
-	provider: z.enum(AIProviderName),
-	name: z.string(),
-	enabledForChat: z.boolean(),
-	keys: z.array(z.object({
-		id: z.string(),
-		name: z.string()
-	}))
-});
-z.object({
-	provider: z.enum(AIProviderName),
-	configId: z.string(),
-	config: AIProviderConfig,
-	auth: AIProviderAuthConfig,
-	platformId: z.string()
-});
+({ ...toolCallBaseShape }), ToolCallType.PIECE, { ...toolCallBaseShape }, ToolCallType.FLOW, { ...toolCallBaseShape }, ToolCallType.MCP, { ...toolCallBaseShape }, ToolCallType.KNOWLEDGE_BASE, { ...toolCallBaseShape }, ToolCallType.UNKNOWN;
+(/* @__PURE__ */ string()).check(/* @__PURE__ */ _minLength(1));
+(/* @__PURE__ */ string()).check(/* @__PURE__ */ _minLength(1)), (/* @__PURE__ */ string()).check(/* @__PURE__ */ _minLength(1));
+(/* @__PURE__ */ string()).check(/* @__PURE__ */ _minLength(1));
+(/* @__PURE__ */ string()).check(/* @__PURE__ */ _regex(/^[a-z0-9][a-z0-9-]{0,62}$/)), (/* @__PURE__ */ string()).check(/* @__PURE__ */ _regex(/^[a-z0-9][a-z0-9-]{0,62}$/));
 AIProviderName.OPENAI, AIProviderName.ANTHROPIC, AIProviderName.GOOGLE, AIProviderName.GOOGLE;
 const OPENAI_CHAT_MODELS = [
 	"gpt-5.5",
@@ -1050,35 +2136,12 @@ function buildProviderCapabilities(provider) {
 	};
 }
 AIProviderName.OPENAI, buildProviderCapabilities(AIProviderName.OPENAI), AIProviderName.ANTHROPIC, buildProviderCapabilities(AIProviderName.ANTHROPIC), AIProviderName.OPENROUTER, buildProviderCapabilities(AIProviderName.OPENROUTER), AIProviderName.AZURE, buildProviderCapabilities(AIProviderName.AZURE), AIProviderName.GOOGLE, buildProviderCapabilities(AIProviderName.GOOGLE), AIProviderName.CLOUDFLARE_GATEWAY, buildProviderCapabilities(AIProviderName.CLOUDFLARE_GATEWAY), AIProviderName.CUSTOM, buildProviderCapabilities(AIProviderName.CUSTOM), AIProviderName.BEDROCK, buildProviderCapabilities(AIProviderName.BEDROCK), AIProviderName.VERTEX, buildProviderCapabilities(AIProviderName.VERTEX), AIProviderName.MISTRAL, buildProviderCapabilities(AIProviderName.MISTRAL), AIProviderName.ACTIVEPIECES, buildProviderCapabilities(AIProviderName.ACTIVEPIECES), AIProviderName.XAI, buildProviderCapabilities(AIProviderName.XAI), AIProviderName.DEEPSEEK, buildProviderCapabilities(AIProviderName.DEEPSEEK), AIProviderName.ZAI, buildProviderCapabilities(AIProviderName.ZAI), AIProviderName.QWEN, buildProviderCapabilities(AIProviderName.QWEN), AIProviderName.MINIMAX, buildProviderCapabilities(AIProviderName.MINIMAX), AIProviderName.MOONSHOT, buildProviderCapabilities(AIProviderName.MOONSHOT);
-const FileResponseInterfaceV1 = z.object({
-	base64Url: z.string(),
-	fileName: z.string(),
-	extension: z.optional(z.string())
-});
-const FileResponseInterfaceV2 = z.object({
-	mimeType: z.string(),
-	url: z.string(),
-	fileName: z.optional(z.string())
-});
-const FileResponseInterface = z.union([FileResponseInterfaceV1, FileResponseInterfaceV2]);
 let HumanInputFormResultTypes = /* @__PURE__ */ function(HumanInputFormResultTypes) {
 	HumanInputFormResultTypes["FILE"] = "file";
 	HumanInputFormResultTypes["MARKDOWN"] = "markdown";
 	return HumanInputFormResultTypes;
 }({});
-z.union([z.object({
-	type: z.literal(HumanInputFormResultTypes.FILE),
-	value: FileResponseInterface
-}), z.object({
-	type: z.literal(HumanInputFormResultTypes.MARKDOWN),
-	value: z.string(),
-	files: z.optional(z.array(FileResponseInterface))
-})]);
-z.object({
-	sessionId: z.string(),
-	message: z.string(),
-	files: z.optional(z.array(z.string()))
-});
+HumanInputFormResultTypes.FILE, HumanInputFormResultTypes.MARKDOWN;
 let FieldType = /* @__PURE__ */ function(FieldType) {
 	FieldType["TEXT"] = "TEXT";
 	FieldType["NUMBER"] = "NUMBER";
@@ -1097,12 +2160,6 @@ let TableAutomationStatus = /* @__PURE__ */ function(TableAutomationStatus) {
 	TableAutomationStatus["DISABLED"] = "DISABLED";
 	return TableAutomationStatus;
 }({});
-let TableWebhookEventType = /* @__PURE__ */ function(TableWebhookEventType) {
-	TableWebhookEventType["RECORD_CREATED"] = "RECORD_CREATED";
-	TableWebhookEventType["RECORD_UPDATED"] = "RECORD_UPDATED";
-	TableWebhookEventType["RECORD_DELETED"] = "RECORD_DELETED";
-	return TableWebhookEventType;
-}({});
 let FilterOperator = /* @__PURE__ */ function(FilterOperator) {
 	FilterOperator["EQ"] = "eq";
 	FilterOperator["NEQ"] = "neq";
@@ -1115,85 +2172,13 @@ let FilterOperator = /* @__PURE__ */ function(FilterOperator) {
 	FilterOperator["NOT_EXISTS"] = "not_exists";
 	return FilterOperator;
 }({});
-z.union([z.object({
-	...BaseModelSchema,
-	name: z.string(),
-	externalId: z.string(),
-	type: z.literal(FieldType.STATIC_DROPDOWN),
-	tableId: z.string(),
-	projectId: z.string(),
-	data: z.object({ options: z.array(z.object({ value: z.string() })) })
-}), z.object({
-	...BaseModelSchema,
-	name: z.string(),
-	externalId: z.string(),
-	type: z.union([
-		z.literal(FieldType.TEXT),
-		z.literal(FieldType.NUMBER),
-		z.literal(FieldType.DATE),
-		z.literal(FieldType.DATETIME)
-	]),
-	tableId: z.string(),
-	projectId: z.string()
-})]);
-z.object({
-	...BaseModelSchema,
-	name: z.string(),
-	folderId: Nullable(z.string()),
-	projectId: z.string(),
-	externalId: z.string(),
-	status: NullableEnum(TableAutomationStatus),
-	trigger: NullableEnum(TableAutomationTrigger)
-});
-z.object({
-	...BaseModelSchema,
-	tableId: z.string(),
-	projectId: z.string(),
-	cells: z.record(z.string(), z.object({
-		updated: z.string(),
-		created: z.string(),
-		value: z.unknown(),
-		fieldName: z.string()
-	}))
-});
-z.object({
-	events: z.array(z.enum(TableWebhookEventType)),
-	webhookUrl: z.string(),
-	flowId: z.string()
-});
-z.object({
-	fields: z.array(z.object({
-		id: z.string(),
-		name: z.string()
-	})),
-	rows: z.array(z.record(z.string(), z.string())),
-	name: z.string()
-});
-z.object({
-	projectId: z.string(),
-	limit: z.optional(z.coerce.number()),
-	cursor: z.optional(z.string()),
-	name: z.optional(z.string()),
-	externalIds: OptionalArrayFromQuery(z.string()),
-	folderId: z.optional(z.string()),
-	folderIds: OptionalArrayFromQuery(z.string())
-});
-z.object({
-	records: z.array(z.array(z.object({
-		fieldId: z.string(),
-		value: coerceToString()
-	}))),
-	tableId: z.string()
-});
-z.object({
-	cells: z.optional(z.array(z.object({
-		fieldId: z.string(),
-		value: coerceToString()
-	}))),
-	tableId: z.string(),
-	agentUpdate: z.optional(z.boolean())
-});
-const Filter = z.discriminatedUnion("operator", [
+({ ...BaseModelSchema }), FieldType.STATIC_DROPDOWN, { ...BaseModelSchema }, FieldType.TEXT, FieldType.NUMBER, FieldType.DATE, FieldType.DATETIME;
+({ ...BaseModelSchema }), Nullable(/* @__PURE__ */ string()), NullableEnum(TableAutomationStatus), NullableEnum(TableAutomationTrigger);
+({ ...BaseModelSchema });
+OptionalArrayFromQuery(/* @__PURE__ */ string()), OptionalArrayFromQuery(/* @__PURE__ */ string());
+coerceToString();
+coerceToString();
+OptionalArrayFromQuery(/* @__PURE__ */ discriminatedUnion("operator", [
 	valueFilter(FilterOperator.EQ),
 	valueFilter(FilterOperator.NEQ),
 	valueFilter(FilterOperator.GT),
@@ -1203,70 +2188,34 @@ const Filter = z.discriminatedUnion("operator", [
 	valueFilter(FilterOperator.CO),
 	existenceFilter(FilterOperator.EXISTS),
 	existenceFilter(FilterOperator.NOT_EXISTS)
-]);
-z.object({
-	tableId: z.string(),
-	limit: z.optional(z.coerce.number()),
-	cursor: z.optional(z.string()),
-	filters: OptionalArrayFromQuery(Filter)
-});
+]));
 function coerceToString() {
-	return z.pipe(z.transform((v) => v === null || v === void 0 ? v : String(v)), z.nullable(z.string()));
+	return /* @__PURE__ */ pipe(/* @__PURE__ */ transform((v) => v === null || v === void 0 ? v : String(v)), /* @__PURE__ */ nullable(/* @__PURE__ */ string()));
 }
 function valueFilter(op) {
-	return z.object({
-		fieldId: z.string(),
-		operator: z.literal(op),
-		value: z.string()
+	return /* @__PURE__ */ object({
+		fieldId: /* @__PURE__ */ string(),
+		operator: /* @__PURE__ */ literal(op),
+		value: /* @__PURE__ */ string()
 	});
 }
 function existenceFilter(op) {
-	return z.object({
-		fieldId: z.string(),
-		operator: z.literal(op)
+	return /* @__PURE__ */ object({
+		fieldId: /* @__PURE__ */ string(),
+		operator: /* @__PURE__ */ literal(op)
 	});
 }
-z.object({
-	status: z.optional(z.number()),
-	body: z.optional(z.unknown()),
-	headers: z.optional(z.record(z.string(), z.string()))
-});
-z.object({
-	...BaseModelSchema,
-	deleted: Nullable(DateOrString),
-	ownerId: z.string(),
-	displayName: z.string(),
-	platformId: z.string(),
-	externalId: Nullable(z.string())
-});
-const McpProperty = z.object({
-	name: z.string(),
-	description: z.optional(z.string()),
-	type: z.string(),
-	required: z.boolean()
-});
-z.object({
-	pieceName: z.string(),
-	triggerName: z.string(),
-	input: z.object({
-		toolName: z.string(),
-		toolDescription: z.string(),
-		inputSchema: z.array(McpProperty),
-		returnsResponse: z.boolean()
-	})
-});
-const PieceProperty = z.union([InputProperty, PieceAuthProperty]);
-const PiecePropertyMap = z.record(z.string(), PieceProperty);
-z.record(z.string(), InputProperty);
+({ ...BaseModelSchema }), Nullable(DateOrString), Nullable(/* @__PURE__ */ string());
+const PiecePropertyMap = /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ union([InputProperty, PieceAuthProperty]));
 let WebhookRenewStrategy = /* @__PURE__ */ function(WebhookRenewStrategy) {
 	WebhookRenewStrategy["CRON"] = "CRON";
 	WebhookRenewStrategy["NONE"] = "NONE";
 	return WebhookRenewStrategy;
 }({});
-const WebhookRenewConfiguration = z.union([z.object({
-	strategy: z.literal(WebhookRenewStrategy.CRON),
-	cronExpression: z.string()
-}), z.object({ strategy: z.literal(WebhookRenewStrategy.NONE) })]);
+const WebhookRenewConfiguration = /* @__PURE__ */ union([/* @__PURE__ */ object({
+	strategy: /* @__PURE__ */ literal(WebhookRenewStrategy.CRON),
+	cronExpression: /* @__PURE__ */ string()
+}), /* @__PURE__ */ object({ strategy: /* @__PURE__ */ literal(WebhookRenewStrategy.NONE) })]);
 var ITrigger = class {
 	constructor(name, displayName, description, requireAuth, props, type, handshakeConfiguration, onHandshake, renewConfiguration, onRenew, onEnable, onDisable, onStart, run, test, sampleData, testStrategy, outputSchema, aiMetadata, classification, propertyGroups) {
 		this.name = name;
@@ -1380,114 +2329,108 @@ function isSemverLessThan(a, b) {
 	if (a2 !== b2) return a2 < b2;
 	return a3 < b3;
 }
-const I18nForPiece = z.optional(z.record(z.string(), z.record(z.string(), z.string())));
-const PieceBase = z.object({
-	id: z.optional(z.string()),
-	name: z.string(),
-	displayName: z.string(),
-	logoUrl: z.string(),
-	description: z.string(),
-	authors: z.array(z.string()),
-	platformId: z.optional(z.string()),
-	directoryPath: z.optional(z.string()),
-	auth: z.optional(z.union([PieceAuthProperty, z.array(PieceAuthProperty)])),
-	version: z.string(),
-	categories: z.optional(z.array(z.enum(PieceCategory))),
-	minimumSupportedRelease: z.optional(z.string()),
-	maximumSupportedRelease: z.optional(z.string()),
-	deprecated: z.optional(z.boolean()),
-	i18n: I18nForPiece
-});
-const Audience = z.enum([
+const PieceBase = /* @__PURE__ */ object({
+	id: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	name: /* @__PURE__ */ string(),
+	displayName: /* @__PURE__ */ string(),
+	logoUrl: /* @__PURE__ */ string(),
+	description: /* @__PURE__ */ string(),
+	authors: /* @__PURE__ */ array(/* @__PURE__ */ string()),
+	platformId: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	directoryPath: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	auth: /* @__PURE__ */ optional(/* @__PURE__ */ union([PieceAuthProperty, /* @__PURE__ */ array(PieceAuthProperty)])),
+	version: /* @__PURE__ */ string(),
+	categories: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ _enum(PieceCategory))),
+	minimumSupportedRelease: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	maximumSupportedRelease: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	deprecated: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	i18n: /* @__PURE__ */ optional(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ string())))
+});
+const Audience = /* @__PURE__ */ _enum([
 	"human",
 	"ai",
 	"both"
 ]);
-const AiMetadata = z.object({
-	description: z.optional(z.string()),
-	idempotent: z.optional(z.boolean())
+const AiMetadata = /* @__PURE__ */ object({
+	description: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	idempotent: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
 });
-const ActionClassification = z.enum([
+const ActionClassification = /* @__PURE__ */ _enum([
 	"READ",
 	"SEARCH",
 	"WRITE",
 	"DESTRUCTIVE"
 ]);
-const PropertyGroupDisplay = z.enum([
-	"tabs",
-	"section",
-	"summary",
-	"builder",
-	"footer"
-]);
-const PropertyGroup = z.object({
-	key: z.string(),
-	display: PropertyGroupDisplay,
-	label: z.optional(z.string()),
-	description: z.optional(z.string()),
-	icon: z.optional(z.string()),
-	props: z.array(z.string())
-});
-const ActionBase = z.object({
-	name: z.string(),
-	displayName: z.string(),
-	description: z.string(),
+const PropertyGroup = /* @__PURE__ */ object({
+	key: /* @__PURE__ */ string(),
+	display: /* @__PURE__ */ _enum([
+		"tabs",
+		"section",
+		"summary",
+		"builder",
+		"footer"
+	]),
+	label: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	description: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	icon: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	props: /* @__PURE__ */ array(/* @__PURE__ */ string())
+});
+const ActionBase = /* @__PURE__ */ object({
+	name: /* @__PURE__ */ string(),
+	displayName: /* @__PURE__ */ string(),
+	description: /* @__PURE__ */ string(),
 	props: PiecePropertyMap,
-	propertyGroups: z.optional(z.array(PropertyGroup)),
-	requireAuth: z.boolean(),
-	errorHandlingOptions: z.optional(ErrorHandlingOptionsParam),
-	outputSchema: z.optional(z.custom()),
-	audience: z.optional(Audience),
-	aiMetadata: z.optional(AiMetadata),
-	classification: z.optional(ActionClassification)
-});
-const TriggerBase = z.object({
-	name: z.string(),
-	displayName: z.string(),
-	description: z.string(),
+	propertyGroups: /* @__PURE__ */ optional(/* @__PURE__ */ array(PropertyGroup)),
+	requireAuth: /* @__PURE__ */ boolean(),
+	errorHandlingOptions: /* @__PURE__ */ optional(ErrorHandlingOptionsParam),
+	outputSchema: /* @__PURE__ */ optional(/* @__PURE__ */ custom()),
+	audience: /* @__PURE__ */ optional(Audience),
+	aiMetadata: /* @__PURE__ */ optional(AiMetadata),
+	classification: /* @__PURE__ */ optional(ActionClassification)
+});
+const TriggerBase = /* @__PURE__ */ object({
+	name: /* @__PURE__ */ string(),
+	displayName: /* @__PURE__ */ string(),
+	description: /* @__PURE__ */ string(),
 	props: PiecePropertyMap,
-	propertyGroups: z.optional(z.array(PropertyGroup)),
-	errorHandlingOptions: z.optional(ErrorHandlingOptionsParam),
-	type: z.enum(TriggerStrategy),
-	sampleData: z.unknown(),
-	handshakeConfiguration: z.optional(z.custom()),
-	renewConfiguration: z.optional(WebhookRenewConfiguration),
-	testStrategy: z.enum(TriggerTestStrategy),
-	outputSchema: z.optional(z.custom()),
-	aiMetadata: z.optional(AiMetadata),
-	classification: z.optional(ActionClassification)
-});
-const PieceMetadata = z.object({
+	propertyGroups: /* @__PURE__ */ optional(/* @__PURE__ */ array(PropertyGroup)),
+	errorHandlingOptions: /* @__PURE__ */ optional(ErrorHandlingOptionsParam),
+	type: /* @__PURE__ */ _enum(TriggerStrategy),
+	sampleData: /* @__PURE__ */ unknown(),
+	handshakeConfiguration: /* @__PURE__ */ optional(/* @__PURE__ */ custom()),
+	renewConfiguration: /* @__PURE__ */ optional(WebhookRenewConfiguration),
+	testStrategy: /* @__PURE__ */ _enum(TriggerTestStrategy),
+	outputSchema: /* @__PURE__ */ optional(/* @__PURE__ */ custom()),
+	aiMetadata: /* @__PURE__ */ optional(AiMetadata),
+	classification: /* @__PURE__ */ optional(ActionClassification)
+});
+const PieceMetadata = /* @__PURE__ */ object({
 	...PieceBase.shape,
-	actions: z.record(z.string(), ActionBase),
-	triggers: z.record(z.string(), TriggerBase)
+	actions: /* @__PURE__ */ record(/* @__PURE__ */ string(), ActionBase),
+	triggers: /* @__PURE__ */ record(/* @__PURE__ */ string(), TriggerBase)
 });
-const PieceMetadataSummary = z.object({
+const PieceMetadataSummary = /* @__PURE__ */ object({
 	...PieceBase.shape,
-	actions: z.number(),
-	triggers: z.number(),
-	suggestedActions: z.optional(z.array(ActionBase)),
-	suggestedTriggers: z.optional(z.array(TriggerBase))
-});
-const PiecePackageMetadata = z.object({
-	projectUsage: z.number(),
-	pieceType: z.enum(PieceType),
-	packageType: z.enum(PackageType),
-	platformId: z.optional(z.string()),
-	archiveId: z.optional(z.string())
-});
-z.object({
+	actions: /* @__PURE__ */ number$1(),
+	triggers: /* @__PURE__ */ number$1(),
+	suggestedActions: /* @__PURE__ */ optional(/* @__PURE__ */ array(ActionBase)),
+	suggestedTriggers: /* @__PURE__ */ optional(/* @__PURE__ */ array(TriggerBase))
+});
+const PiecePackageMetadata = /* @__PURE__ */ object({
+	projectUsage: /* @__PURE__ */ number$1(),
+	pieceType: /* @__PURE__ */ _enum(PieceType),
+	packageType: /* @__PURE__ */ _enum(PackageType),
+	platformId: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	archiveId: /* @__PURE__ */ optional(/* @__PURE__ */ string())
+});
+({
 	...PieceMetadata.shape,
 	...PiecePackageMetadata.shape
 });
-z.object({
+({
 	...PieceMetadataSummary.shape,
 	...PiecePackageMetadata.shape
 });
-z.object({
-	name: z.string(),
-	version: z.string()
-});
 function reactorOf(ctx) {
 	const reactor = ctx !== null && typeof ctx === "object" ? ctx.reactor : void 0;
 	if (!reactor) throw new Error("ctx.reactor is not available: this piece is not running on a Powerhouse reactor");