@statelyai/sdk 0.40.0 → 0.41.0

package/dist/studio-DH7OeLao.mjs

@@ -0,0 +1,1604 @@
+import { r as __exportAll, t as __commonJSMin } from "./chunk-D1OLi6Wq.mjs";
+import { $ as ZodString, $n as uuid, $r as _property, $t as int, A as ZodJWT, An as preprocess, Ar as _coercedDate, At as boolean$1, B as ZodNull, Bn as stringbool, Br as _lte, Bt as discriminatedUnion, C as ZodExactOptional, Ci as config, Cn as nullish, Cr as iso_exports, Ct as _undefined, D as ZodIPv4, Dn as partialRecord, Dr as TimePrecision, Dt as base64, E as ZodGUID, En as optional, Er as toJSONSchema, Et as array, F as ZodMap, Fn as schemas_exports, Fr as _gte, Ft as cuid, G as ZodOptional, Gn as transform, Gr as _minSize, Gt as file, H as ZodNumber, Hn as superRefine, Hr as _maxSize, Ht as email, I as ZodNaN, In as set, Ir as _includes, It as cuid2, J as ZodPreprocess, Jn as uint64, Jr as _nonnegative, Jt as guid, K as ZodPipe, Kn as tuple, Kr as _multipleOf, Kt as float32, L as ZodNanoID, Ln as strictObject, Lr as _length, Lt as custom, M as ZodLazy, Mn as readonly, Mr as _coercedString, Mt as cidrv4, N as ZodLiteral, Nn as record, Nr as _endsWith, Nt as cidrv6, O as ZodIPv6, On as pipe, Or as _coercedBigint, Ot as base64url, P as ZodMAC, Pn as refine, Pr as _gt, Pt as codec, Q as ZodSet, Qn as url, Qr as _positive, Qt as httpUrl, R as ZodNever, Rn as string$1, Rr as _lowercase, Rt as date$1, S as ZodEnum, Si as NEVER, Sn as nullable, Sr as ZodISOTime, St as _null, T as ZodFunction, Tn as object, Tr as core_exports, Tt as any, U as ZodNumberFormat, Un as symbol, Ur as _mime, Ut as emoji, V as ZodNullable, Vn as success, Vr as _maxLength, Vt as e164, W as ZodObject, Wn as templateLiteral, Wr as _minLength, Wt as exactOptional, X as ZodReadonly, Xn as union, Xr as _normalize, Xt as hex, Y as ZodPromise, Yn as ulid, Yr as _nonpositive, Yt as hash, Z as ZodRecord, Zn as unknown, Zr as _overwrite, Zt as hostname, _ as ZodDefault, _i as prettifyError, _n as nan, _r as ZodError, _t as _catch, a as ZodBigInt, ai as _toUpperCase, an as ipv6, ar as decode, at as ZodTuple, b as ZodEmail, bi as util_exports, bn as never, br as ZodISODateTime, bt as _function, c as ZodCIDRv4, ci as $input, cn as keyof, cr as encodeAsync, ct as ZodURL, d as ZodCUID2, di as registry, dn as literal, dr as safeDecode, dt as ZodUnion, ei as _regex, en as int32, er as uuidv4, et as ZodStringFormat, f as ZodCatch, fi as locales_exports, fn as looseObject, fr as safeDecodeAsync, ft as ZodUnknown, g as ZodDate, gi as formatError, gn as meta, gr as safeParseAsync, gt as _ZodString, h as ZodCustomStringFormat, hi as flattenError, hn as map, hr as safeParse, ht as ZodXor, i as ZodBase64URL, ii as _toLowerCase, in as ipv4, ir as xor, it as ZodTransform, j as ZodKSUID, jn as promise, jr as _coercedNumber, jt as check, k as ZodIntersection, kn as prefault, kr as _coercedBoolean, kt as bigint$1, l as ZodCIDRv6, li as $output, ln as ksuid, lr as parse, lt as ZodUUID, m as ZodCustom, mi as regexes_exports, mn as mac, mr as safeEncodeAsync, mt as ZodXID, n as ZodArray, ni as _slugify, nn as intersection, nr as uuidv7, nt as ZodSymbol, o as ZodBigIntFormat, oi as _trim, on as json, or as decodeAsync, ot as ZodType, p as ZodCodec, pi as en_default, pn as looseRecord, pr as safeEncode, pt as ZodVoid, q as ZodPrefault, qn as uint32, qr as _negative, qt as float64, r as ZodBase64, ri as _startsWith, rn as invertCodec, rr as xid, rt as ZodTemplateLiteral, s as ZodBoolean, si as _uppercase, sn as jwt, sr as encode, st as ZodULID, t as ZodAny, ti as _size, tn as int64, tr as uuidv6, tt as ZodSuccess, u as ZodCUID, ui as globalRegistry, un as lazy, ur as parseAsync, ut as ZodUndefined, v as ZodDiscriminatedUnion, vi as treeifyError, vn as nanoid, vr as ZodRealError, vt as _default, w as ZodFile, wn as number$1, wr as checks_exports, wt as _void, x as ZodEmoji, xi as $brand, xn as nonoptional, xr as ZodISODuration, xt as _instanceof, y as ZodE164, yi as clone, yn as nativeEnum, yr as ZodISODate, yt as _enum, z as ZodNonOptional, zn as stringFormat, zr as _lt, zt as describe } from "./schemas-DsQ8UYlM.mjs";
+import { createAuthorizationHeader, getCredentialToken } from "./auth.mjs";
+
+//#region ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.5.0_zod@4.4.3/node_modules/@asteasolutions/zod-to-openapi/dist/index.cjs
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/******************************************************************************
+	Copyright (c) Microsoft Corporation.
+	
+	Permission to use, copy, modify, and/or distribute this software for any
+	purpose with or without fee is hereby granted.
+	
+	THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+	REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+	AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+	INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+	OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+	PERFORMANCE OF THIS SOFTWARE.
+	***************************************************************************** */
+	function __rest(s, e) {
+		var t = {};
+		for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+		if (s != null && typeof Object.getOwnPropertySymbols === "function") {
+			for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+		}
+		return t;
+	}
+	const ZodTypeKeys = {
+		ZodAny: "any",
+		ZodArray: "array",
+		ZodBigInt: "bigint",
+		ZodBoolean: "boolean",
+		ZodDefault: "default",
+		ZodPrefault: "prefault",
+		ZodTransform: "transform",
+		ZodEnum: "enum",
+		ZodIntersection: "intersection",
+		ZodLazy: "lazy",
+		ZodLiteral: "literal",
+		ZodNever: "never",
+		ZodNull: "null",
+		ZodNullable: "nullable",
+		ZodNumber: "number",
+		ZodNonOptional: "nonoptional",
+		ZodObject: "object",
+		ZodOptional: "optional",
+		ZodPipe: "pipe",
+		ZodReadonly: "readonly",
+		ZodRecord: "record",
+		ZodString: "string",
+		ZodTuple: "tuple",
+		ZodType: "type",
+		ZodUnion: "union",
+		ZodDiscriminatedUnion: "union",
+		ZodUnknown: "unknown",
+		ZodVoid: "void",
+		ZodDate: "date",
+		ZodTemplateLiteral: "template_literal"
+	};
+	function isZodType(schema, typeNames) {
+		return (Array.isArray(typeNames) ? typeNames : [typeNames]).some((typeName) => {
+			var _a;
+			const typeNameMatch = ((_a = schema === null || schema === void 0 ? void 0 : schema.def) === null || _a === void 0 ? void 0 : _a.type) === ZodTypeKeys[typeName];
+			if (typeName === "ZodDiscriminatedUnion") return typeNameMatch && "discriminator" in schema.def;
+			return typeNameMatch;
+		});
+	}
+	function isAnyZodType(schema) {
+		return schema && "def" in schema;
+	}
+	var $ZodRegistry = class {
+		constructor() {
+			this._map = /* @__PURE__ */ new Map();
+			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) {
+				if (this._idmap.has(meta.id)) throw new Error(`ID ${meta.id} already exists in the registry`);
+				this._idmap.set(meta.id, schema);
+			}
+			return this;
+		}
+		clear() {
+			this._map = /* @__PURE__ */ new Map();
+			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;
+				return {
+					...pm,
+					...this._map.get(schema)
+				};
+			}
+			return this._map.get(schema);
+		}
+		has(schema) {
+			return this._map.has(schema);
+		}
+	};
+	function registry() {
+		return new $ZodRegistry();
+	}
+	function isUndefined(value) {
+		return value === void 0;
+	}
+	function omit(object, keys) {
+		const result = {};
+		Object.entries(object).forEach(([key, value]) => {
+			if (!keys.some((keyToOmit) => keyToOmit === key)) result[key] = value;
+		});
+		return result;
+	}
+	function omitBy(object, predicate) {
+		const result = {};
+		Object.entries(object).forEach(([key, value]) => {
+			if (!predicate(value, key)) result[key] = value;
+		});
+		return result;
+	}
+	/**
+	* @deprecated This is not really deprecated but this should always be used with
+	* caution. Using it may alter the behavior of the library and the generated schemas.
+	*/
+	const zodToOpenAPIRegistry = registry();
+	var Metadata = class {
+		static collectMetadata(schema, metadata) {
+			const currentMetadata = this.getMetadataFromRegistry(schema);
+			const _internal = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata._internal), metadata === null || metadata === void 0 ? void 0 : metadata._internal);
+			const param = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), metadata === null || metadata === void 0 ? void 0 : metadata.param);
+			const totalMetadata = Object.assign(Object.assign(Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : {}), currentMetadata), metadata), Object.keys(param).length > 0 ? { param } : {});
+			if (isZodType(schema, [
+				"ZodOptional",
+				"ZodNullable",
+				"ZodDefault",
+				"ZodPrefault",
+				"ZodReadonly",
+				"ZodNonOptional"
+			]) && isAnyZodType(schema._zod.def.innerType)) return this.collectMetadata(schema._zod.def.innerType, totalMetadata);
+			if (isZodType(schema, "ZodPipe")) {
+				const inSchema = schema._zod.def.in;
+				const outSchema = schema._zod.def.out;
+				if (isZodType(inSchema, "ZodTransform") && isAnyZodType(outSchema)) return this.collectMetadata(outSchema, totalMetadata);
+				if (isAnyZodType(inSchema)) return this.collectMetadata(inSchema, totalMetadata);
+			}
+			return totalMetadata;
+		}
+		/**
+		* @deprecated Use one of `getOpenApiMetadata` or `getInternalMetadata` instead
+		*/
+		static getMetadata(zodSchema) {
+			return this.collectMetadata(zodSchema);
+		}
+		static getOpenApiMetadata(zodSchema) {
+			const metadata = this.collectMetadata(zodSchema);
+			const _a = metadata !== null && metadata !== void 0 ? metadata : {}, { _internal } = _a;
+			return __rest(_a, ["_internal"]);
+		}
+		static getInternalMetadata(zodSchema) {
+			var _a;
+			return (_a = this.collectMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a._internal;
+		}
+		static getParamMetadata(zodSchema) {
+			const metadata = this.collectMetadata(zodSchema);
+			return Object.assign(Object.assign({}, metadata), { param: Object.assign(Object.assign({}, (metadata === null || metadata === void 0 ? void 0 : metadata.description) ? { description: metadata.description } : {}), metadata === null || metadata === void 0 ? void 0 : metadata.param) });
+		}
+		/**
+		* A method that omits all custom keys added to the regular OpenAPI
+		* metadata properties
+		*/
+		static buildSchemaMetadata(metadata) {
+			return omitBy(omit(metadata, ["param", "_internal"]), isUndefined);
+		}
+		static buildParameterMetadata(metadata) {
+			return omitBy(metadata, isUndefined);
+		}
+		static applySchemaMetadata(initialData, metadata) {
+			return omitBy(Object.assign(Object.assign({}, initialData), this.buildSchemaMetadata(metadata)), isUndefined);
+		}
+		static getRefId(zodSchema) {
+			var _a;
+			return (_a = this.getInternalMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a.refId;
+		}
+		static unwrapChained(schema) {
+			return this.unwrapUntil(schema);
+		}
+		static getDefaultValue(zodSchema) {
+			var _a;
+			const unwrapped = (_a = this.unwrapUntil(zodSchema, "ZodDefault")) !== null && _a !== void 0 ? _a : this.unwrapUntil(zodSchema, "ZodPrefault");
+			return unwrapped === null || unwrapped === void 0 ? void 0 : unwrapped._zod.def.defaultValue;
+		}
+		static unwrapUntil(schema, typeName) {
+			if (typeName && isZodType(schema, typeName)) return schema;
+			if (isZodType(schema, [
+				"ZodOptional",
+				"ZodNullable",
+				"ZodDefault",
+				"ZodPrefault",
+				"ZodReadonly",
+				"ZodNonOptional"
+			]) && isAnyZodType(schema._zod.def.innerType)) return this.unwrapUntil(schema._zod.def.innerType, typeName);
+			if (isZodType(schema, "ZodPipe")) {
+				const inSchema = schema._zod.def.in;
+				const outSchema = schema._zod.def.out;
+				if (isZodType(inSchema, "ZodTransform") && isAnyZodType(outSchema)) return this.unwrapUntil(outSchema, typeName);
+				if (isAnyZodType(inSchema)) return this.unwrapUntil(inSchema, typeName);
+			}
+			return typeName ? void 0 : schema;
+		}
+		static getMetadataFromInternalRegistry(zodSchema) {
+			return zodToOpenAPIRegistry.get(zodSchema);
+		}
+		static getMetadataFromRegistry(zodSchema) {
+			const internal = this.getMetadataFromInternalRegistry(zodSchema);
+			const general = zodSchema.meta();
+			if (!internal) return general;
+			const { _internal } = internal, rest = __rest(internal, ["_internal"]);
+			const _a = general !== null && general !== void 0 ? general : {}, { id, title } = _a, restGeneral = __rest(_a, ["id", "title"]);
+			return Object.assign(Object.assign(Object.assign({ _internal: Object.assign(Object.assign({}, id ? { refId: id } : {}), _internal) }, rest), title ? { description: title } : {}), restGeneral);
+		}
+		static setMetadataInRegistry(zodSchema, metadata) {
+			zodToOpenAPIRegistry.add(zodSchema, metadata);
+		}
+	};
+	function preserveMetadataFromModifier(zodSchema, modifier) {
+		const zodModifier = zodSchema[modifier];
+		if (typeof zodModifier !== "function") return;
+		zodSchema[modifier] = function(...args) {
+			const result = zodModifier.apply(this, args);
+			const meta = Metadata.getMetadataFromRegistry(this);
+			if (meta) Metadata.setMetadataInRegistry(result, meta);
+			return result;
+		};
+	}
+	function extendZodWithOpenApi(zod) {
+		if (typeof zod.ZodType.prototype.openapi !== "undefined") return;
+		zod.ZodType.prototype.openapi = function(...args) {
+			const { refId, metadata, options } = getOpenApiConfiguration(...args);
+			const _a = metadata !== null && metadata !== void 0 ? metadata : {}, { param } = _a, restOfOpenApi = __rest(_a, ["param"]);
+			const allMetadata = Metadata.getMetadataFromRegistry(this);
+			const _b = allMetadata !== null && allMetadata !== void 0 ? allMetadata : {}, { _internal: internalMetadata } = _b, currentMetadata = __rest(_b, ["_internal"]);
+			const _internal = Object.assign(Object.assign(Object.assign({}, internalMetadata), options), refId ? { refId } : void 0);
+			const resultMetadata = Object.assign(Object.assign(Object.assign({}, currentMetadata), restOfOpenApi), (currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param) || param ? { param: Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), param) } : void 0);
+			const result = new this.constructor(this._def);
+			function setMetadata(schema) {
+				Metadata.setMetadataInRegistry(schema, Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : void 0), resultMetadata));
+			}
+			setMetadata(result);
+			/**
+			* In order to handle z.json() which is implemented as:
+			*
+			* const jsonSchema = lazy(() => { return union([ ... ]) });
+			* return jsonSchema;
+			*
+			* We need to not only set the metadata to the resulting schema (which would be different
+			* from `jsonSchema`), but also to the original lazy schema so that the _internal metadata (refId)
+			* is also present in the internally used `jsonSchema`.
+			*/
+			if (isZodType(result, "ZodLazy")) setMetadata(this);
+			if (isZodType(result, "ZodObject")) {
+				const currentMetadata = Metadata.getMetadataFromRegistry(result);
+				const originalExtend = result.extend;
+				result.extend = function(...args) {
+					const extendedResult = originalExtend.apply(result, args);
+					const _a = currentMetadata !== null && currentMetadata !== void 0 ? currentMetadata : {}, { _internal } = _a, rest = __rest(_a, ["_internal"]);
+					Metadata.setMetadataInRegistry(extendedResult, { _internal: { extendedFrom: (_internal === null || _internal === void 0 ? void 0 : _internal.refId) ? {
+						refId: _internal.refId,
+						schema: result
+					} : _internal === null || _internal === void 0 ? void 0 : _internal.extendedFrom } });
+					return extendedResult.openapi(rest);
+				};
+				preserveMetadataFromModifier(result, "catchall");
+			}
+			preserveMetadataFromModifier(result, "optional");
+			preserveMetadataFromModifier(result, "nullable");
+			preserveMetadataFromModifier(result, "default");
+			preserveMetadataFromModifier(result, "transform");
+			preserveMetadataFromModifier(result, "refine");
+			preserveMetadataFromModifier(result, "length");
+			preserveMetadataFromModifier(result, "min");
+			preserveMetadataFromModifier(result, "max");
+			const originalMeta = result.meta;
+			result.meta = function(...args) {
+				const result = originalMeta.apply(this, args);
+				if (args[0]) {
+					const meta = Metadata.getMetadataFromInternalRegistry(this);
+					if (meta) Metadata.setMetadataInRegistry(result, Object.assign(Object.assign({}, meta), args[0]));
+				}
+				return result;
+			};
+			return result;
+		};
+	}
+	function getOpenApiConfiguration(refOrOpenapi, metadataOrOptions, options) {
+		if (typeof refOrOpenapi === "string") return {
+			refId: refOrOpenapi,
+			metadata: metadataOrOptions,
+			options
+		};
+		return {
+			refId: void 0,
+			metadata: refOrOpenapi,
+			options: metadataOrOptions
+		};
+	}
+	exports.extendZodWithOpenApi = extendZodWithOpenApi;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/compat.js
+/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
+const ZodIssueCode = {
+	invalid_type: "invalid_type",
+	too_big: "too_big",
+	too_small: "too_small",
+	invalid_format: "invalid_format",
+	not_multiple_of: "not_multiple_of",
+	unrecognized_keys: "unrecognized_keys",
+	invalid_union: "invalid_union",
+	invalid_key: "invalid_key",
+	invalid_element: "invalid_element",
+	invalid_value: "invalid_value",
+	custom: "custom"
+};
+/** @deprecated Use `z.config(params)` instead. */
+function setErrorMap(map) {
+	config({ customError: map });
+}
+/** @deprecated Use `z.config()` instead. */
+function getErrorMap() {
+	return config().customError;
+}
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+var ZodFirstPartyTypeKind;
+(function(ZodFirstPartyTypeKind) {})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/from-json-schema.js
+const z = {
+	...schemas_exports,
+	...checks_exports,
+	iso: iso_exports
+};
+const RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
+	"$schema",
+	"$ref",
+	"$defs",
+	"definitions",
+	"$id",
+	"id",
+	"$comment",
+	"$anchor",
+	"$vocabulary",
+	"$dynamicRef",
+	"$dynamicAnchor",
+	"type",
+	"enum",
+	"const",
+	"anyOf",
+	"oneOf",
+	"allOf",
+	"not",
+	"properties",
+	"required",
+	"additionalProperties",
+	"patternProperties",
+	"propertyNames",
+	"minProperties",
+	"maxProperties",
+	"items",
+	"prefixItems",
+	"additionalItems",
+	"minItems",
+	"maxItems",
+	"uniqueItems",
+	"contains",
+	"minContains",
+	"maxContains",
+	"minLength",
+	"maxLength",
+	"pattern",
+	"format",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf",
+	"description",
+	"default",
+	"contentEncoding",
+	"contentMediaType",
+	"contentSchema",
+	"unevaluatedItems",
+	"unevaluatedProperties",
+	"if",
+	"then",
+	"else",
+	"dependentSchemas",
+	"dependentRequired",
+	"nullable",
+	"readOnly"
+]);
+function detectVersion(schema, defaultTarget) {
+	const $schema = schema.$schema;
+	if ($schema === "https://json-schema.org/draft/2020-12/schema") return "draft-2020-12";
+	if ($schema === "http://json-schema.org/draft-07/schema#") return "draft-7";
+	if ($schema === "http://json-schema.org/draft-04/schema#") return "draft-4";
+	return defaultTarget ?? "draft-2020-12";
+}
+function resolveRef(ref, ctx) {
+	if (!ref.startsWith("#")) throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
+	const path = ref.slice(1).split("/").filter(Boolean);
+	if (path.length === 0) return ctx.rootSchema;
+	const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
+	if (path[0] === defsKey) {
+		const key = path[1];
+		if (!key || !ctx.defs[key]) throw new Error(`Reference not found: ${ref}`);
+		return ctx.defs[key];
+	}
+	throw new Error(`Reference not found: ${ref}`);
+}
+function convertBaseSchema(schema, ctx) {
+	if (schema.not !== void 0) {
+		if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) return z.never();
+		throw new Error("not is not supported in Zod (except { not: {} } for never)");
+	}
+	if (schema.unevaluatedItems !== void 0) throw new Error("unevaluatedItems is not supported");
+	if (schema.unevaluatedProperties !== void 0) throw new Error("unevaluatedProperties is not supported");
+	if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) throw new Error("Conditional schemas (if/then/else) are not supported");
+	if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) throw new Error("dependentSchemas and dependentRequired are not supported");
+	if (schema.$ref) {
+		const refPath = schema.$ref;
+		if (ctx.refs.has(refPath)) return ctx.refs.get(refPath);
+		if (ctx.processing.has(refPath)) return z.lazy(() => {
+			if (!ctx.refs.has(refPath)) throw new Error(`Circular reference not resolved: ${refPath}`);
+			return ctx.refs.get(refPath);
+		});
+		ctx.processing.add(refPath);
+		const zodSchema = convertSchema(resolveRef(refPath, ctx), ctx);
+		ctx.refs.set(refPath, zodSchema);
+		ctx.processing.delete(refPath);
+		return zodSchema;
+	}
+	if (schema.enum !== void 0) {
+		const enumValues = schema.enum;
+		if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) return z.null();
+		if (enumValues.length === 0) return z.never();
+		if (enumValues.length === 1) return z.literal(enumValues[0]);
+		if (enumValues.every((v) => typeof v === "string")) return z.enum(enumValues);
+		const literalSchemas = enumValues.map((v) => z.literal(v));
+		if (literalSchemas.length < 2) return literalSchemas[0];
+		return z.union([
+			literalSchemas[0],
+			literalSchemas[1],
+			...literalSchemas.slice(2)
+		]);
+	}
+	if (schema.const !== void 0) return z.literal(schema.const);
+	const type = schema.type;
+	if (Array.isArray(type)) {
+		const typeSchemas = type.map((t) => {
+			return convertBaseSchema({
+				...schema,
+				type: t
+			}, ctx);
+		});
+		if (typeSchemas.length === 0) return z.never();
+		if (typeSchemas.length === 1) return typeSchemas[0];
+		return z.union(typeSchemas);
+	}
+	if (!type) return z.any();
+	let zodSchema;
+	switch (type) {
+		case "string": {
+			let stringSchema = z.string();
+			if (schema.format) {
+				const format = schema.format;
+				if (format === "email") stringSchema = stringSchema.check(z.email());
+				else if (format === "uri" || format === "uri-reference") stringSchema = stringSchema.check(z.url());
+				else if (format === "uuid" || format === "guid") stringSchema = stringSchema.check(z.uuid());
+				else if (format === "date-time") stringSchema = stringSchema.check(z.iso.datetime());
+				else if (format === "date") stringSchema = stringSchema.check(z.iso.date());
+				else if (format === "time") stringSchema = stringSchema.check(z.iso.time());
+				else if (format === "duration") stringSchema = stringSchema.check(z.iso.duration());
+				else if (format === "ipv4") stringSchema = stringSchema.check(z.ipv4());
+				else if (format === "ipv6") stringSchema = stringSchema.check(z.ipv6());
+				else if (format === "mac") stringSchema = stringSchema.check(z.mac());
+				else if (format === "cidr") stringSchema = stringSchema.check(z.cidrv4());
+				else if (format === "cidr-v6") stringSchema = stringSchema.check(z.cidrv6());
+				else if (format === "base64") stringSchema = stringSchema.check(z.base64());
+				else if (format === "base64url") stringSchema = stringSchema.check(z.base64url());
+				else if (format === "e164") stringSchema = stringSchema.check(z.e164());
+				else if (format === "jwt") stringSchema = stringSchema.check(z.jwt());
+				else if (format === "emoji") stringSchema = stringSchema.check(z.emoji());
+				else if (format === "nanoid") stringSchema = stringSchema.check(z.nanoid());
+				else if (format === "cuid") stringSchema = stringSchema.check(z.cuid());
+				else if (format === "cuid2") stringSchema = stringSchema.check(z.cuid2());
+				else if (format === "ulid") stringSchema = stringSchema.check(z.ulid());
+				else if (format === "xid") stringSchema = stringSchema.check(z.xid());
+				else if (format === "ksuid") stringSchema = stringSchema.check(z.ksuid());
+			}
+			if (typeof schema.minLength === "number") stringSchema = stringSchema.min(schema.minLength);
+			if (typeof schema.maxLength === "number") stringSchema = stringSchema.max(schema.maxLength);
+			if (schema.pattern) stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+			zodSchema = stringSchema;
+			break;
+		}
+		case "number":
+		case "integer": {
+			let numberSchema = type === "integer" ? z.number().int() : z.number();
+			if (typeof schema.minimum === "number") numberSchema = numberSchema.min(schema.minimum);
+			if (typeof schema.maximum === "number") numberSchema = numberSchema.max(schema.maximum);
+			if (typeof schema.exclusiveMinimum === "number") numberSchema = numberSchema.gt(schema.exclusiveMinimum);
+			else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") numberSchema = numberSchema.gt(schema.minimum);
+			if (typeof schema.exclusiveMaximum === "number") numberSchema = numberSchema.lt(schema.exclusiveMaximum);
+			else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") numberSchema = numberSchema.lt(schema.maximum);
+			if (typeof schema.multipleOf === "number") numberSchema = numberSchema.multipleOf(schema.multipleOf);
+			zodSchema = numberSchema;
+			break;
+		}
+		case "boolean":
+			zodSchema = z.boolean();
+			break;
+		case "null":
+			zodSchema = z.null();
+			break;
+		case "object": {
+			const shape = {};
+			const properties = schema.properties || {};
+			const requiredSet = new Set(schema.required || []);
+			for (const [key, propSchema] of Object.entries(properties)) {
+				const propZodSchema = convertSchema(propSchema, ctx);
+				shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
+			}
+			if (schema.propertyNames) {
+				const keySchema = convertSchema(schema.propertyNames, ctx);
+				const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
+				if (Object.keys(shape).length === 0) {
+					zodSchema = z.record(keySchema, valueSchema);
+					break;
+				}
+				const objectSchema = z.object(shape).passthrough();
+				const recordSchema = z.looseRecord(keySchema, valueSchema);
+				zodSchema = z.intersection(objectSchema, recordSchema);
+				break;
+			}
+			if (schema.patternProperties) {
+				const patternProps = schema.patternProperties;
+				const patternKeys = Object.keys(patternProps);
+				const looseRecords = [];
+				for (const pattern of patternKeys) {
+					const patternValue = convertSchema(patternProps[pattern], ctx);
+					const keySchema = z.string().regex(new RegExp(pattern));
+					looseRecords.push(z.looseRecord(keySchema, patternValue));
+				}
+				const schemasToIntersect = [];
+				if (Object.keys(shape).length > 0) schemasToIntersect.push(z.object(shape).passthrough());
+				schemasToIntersect.push(...looseRecords);
+				if (schemasToIntersect.length === 0) zodSchema = z.object({}).passthrough();
+				else if (schemasToIntersect.length === 1) zodSchema = schemasToIntersect[0];
+				else {
+					let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+					for (let i = 2; i < schemasToIntersect.length; i++) result = z.intersection(result, schemasToIntersect[i]);
+					zodSchema = result;
+				}
+				break;
+			}
+			const objectSchema = z.object(shape);
+			if (schema.additionalProperties === false) zodSchema = objectSchema.strict();
+			else if (typeof schema.additionalProperties === "object") zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
+			else zodSchema = objectSchema.passthrough();
+			break;
+		}
+		case "array": {
+			const prefixItems = schema.prefixItems;
+			const items = schema.items;
+			if (prefixItems && Array.isArray(prefixItems)) {
+				const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
+				const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
+				if (rest) zodSchema = z.tuple(tupleItems).rest(rest);
+				else zodSchema = z.tuple(tupleItems);
+				if (typeof schema.minItems === "number") zodSchema = zodSchema.check(z.minLength(schema.minItems));
+				if (typeof schema.maxItems === "number") zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+			} else if (Array.isArray(items)) {
+				const tupleItems = items.map((item) => convertSchema(item, ctx));
+				const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
+				if (rest) zodSchema = z.tuple(tupleItems).rest(rest);
+				else zodSchema = z.tuple(tupleItems);
+				if (typeof schema.minItems === "number") zodSchema = zodSchema.check(z.minLength(schema.minItems));
+				if (typeof schema.maxItems === "number") zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+			} else if (items !== void 0) {
+				const element = convertSchema(items, ctx);
+				let arraySchema = z.array(element);
+				if (typeof schema.minItems === "number") arraySchema = arraySchema.min(schema.minItems);
+				if (typeof schema.maxItems === "number") arraySchema = arraySchema.max(schema.maxItems);
+				zodSchema = arraySchema;
+			} else zodSchema = z.array(z.any());
+			break;
+		}
+		default: throw new Error(`Unsupported type: ${type}`);
+	}
+	return zodSchema;
+}
+function convertSchema(schema, ctx) {
+	if (typeof schema === "boolean") return schema ? z.any() : z.never();
+	let baseSchema = convertBaseSchema(schema, ctx);
+	const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
+	if (schema.anyOf && Array.isArray(schema.anyOf)) {
+		const options = schema.anyOf.map((s) => convertSchema(s, ctx));
+		const anyOfUnion = z.union(options);
+		baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+	}
+	if (schema.oneOf && Array.isArray(schema.oneOf)) {
+		const options = schema.oneOf.map((s) => convertSchema(s, ctx));
+		const oneOfUnion = z.xor(options);
+		baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+	}
+	if (schema.allOf && Array.isArray(schema.allOf)) if (schema.allOf.length === 0) baseSchema = hasExplicitType ? baseSchema : z.any();
+	else {
+		let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+		const startIdx = hasExplicitType ? 0 : 1;
+		for (let i = startIdx; i < schema.allOf.length; i++) result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
+		baseSchema = result;
+	}
+	if (schema.nullable === true && ctx.version === "openapi-3.0") baseSchema = z.nullable(baseSchema);
+	if (schema.readOnly === true) baseSchema = z.readonly(baseSchema);
+	if (schema.default !== void 0) baseSchema = baseSchema.default(schema.default);
+	const extraMeta = {};
+	for (const key of [
+		"$id",
+		"id",
+		"$comment",
+		"$anchor",
+		"$vocabulary",
+		"$dynamicRef",
+		"$dynamicAnchor"
+	]) if (key in schema) extraMeta[key] = schema[key];
+	for (const key of [
+		"contentEncoding",
+		"contentMediaType",
+		"contentSchema"
+	]) if (key in schema) extraMeta[key] = schema[key];
+	for (const key of Object.keys(schema)) if (!RECOGNIZED_KEYS.has(key)) extraMeta[key] = schema[key];
+	if (Object.keys(extraMeta).length > 0) ctx.registry.add(baseSchema, extraMeta);
+	if (schema.description) baseSchema = baseSchema.describe(schema.description);
+	return baseSchema;
+}
+/**
+* Converts a JSON Schema to a Zod schema. This function should be considered semi-experimental. It's behavior is liable to change. */
+function fromJSONSchema(schema, params) {
+	if (typeof schema === "boolean") return schema ? z.any() : z.never();
+	let normalized;
+	try {
+		normalized = JSON.parse(JSON.stringify(schema));
+	} catch {
+		throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
+	}
+	const ctx = {
+		version: detectVersion(normalized, params?.defaultTarget),
+		defs: normalized.$defs || normalized.definitions || {},
+		refs: /* @__PURE__ */ new Map(),
+		processing: /* @__PURE__ */ new Set(),
+		rootSchema: normalized,
+		registry: params?.registry ?? globalRegistry
+	};
+	return convertSchema(normalized, ctx);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/coerce.js
+var coerce_exports = /* @__PURE__ */ __exportAll({
+	bigint: () => bigint,
+	boolean: () => boolean,
+	date: () => date,
+	number: () => number,
+	string: () => string
+});
+function string(params) {
+	return _coercedString(ZodString, params);
+}
+function number(params) {
+	return _coercedNumber(ZodNumber, params);
+}
+function boolean(params) {
+	return _coercedBoolean(ZodBoolean, params);
+}
+function bigint(params) {
+	return _coercedBigint(ZodBigInt, params);
+}
+function date(params) {
+	return _coercedDate(ZodDate, params);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
+var external_exports = /* @__PURE__ */ __exportAll({
+	$brand: () => $brand,
+	$input: () => $input,
+	$output: () => $output,
+	NEVER: () => NEVER,
+	TimePrecision: () => TimePrecision,
+	ZodAny: () => ZodAny,
+	ZodArray: () => ZodArray,
+	ZodBase64: () => ZodBase64,
+	ZodBase64URL: () => ZodBase64URL,
+	ZodBigInt: () => ZodBigInt,
+	ZodBigIntFormat: () => ZodBigIntFormat,
+	ZodBoolean: () => ZodBoolean,
+	ZodCIDRv4: () => ZodCIDRv4,
+	ZodCIDRv6: () => ZodCIDRv6,
+	ZodCUID: () => ZodCUID,
+	ZodCUID2: () => ZodCUID2,
+	ZodCatch: () => ZodCatch,
+	ZodCodec: () => ZodCodec,
+	ZodCustom: () => ZodCustom,
+	ZodCustomStringFormat: () => ZodCustomStringFormat,
+	ZodDate: () => ZodDate,
+	ZodDefault: () => ZodDefault,
+	ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+	ZodE164: () => ZodE164,
+	ZodEmail: () => ZodEmail,
+	ZodEmoji: () => ZodEmoji,
+	ZodEnum: () => ZodEnum,
+	ZodError: () => ZodError,
+	ZodExactOptional: () => ZodExactOptional,
+	ZodFile: () => ZodFile,
+	ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+	ZodFunction: () => ZodFunction,
+	ZodGUID: () => ZodGUID,
+	ZodIPv4: () => ZodIPv4,
+	ZodIPv6: () => ZodIPv6,
+	ZodISODate: () => ZodISODate,
+	ZodISODateTime: () => ZodISODateTime,
+	ZodISODuration: () => ZodISODuration,
+	ZodISOTime: () => ZodISOTime,
+	ZodIntersection: () => ZodIntersection,
+	ZodIssueCode: () => ZodIssueCode,
+	ZodJWT: () => ZodJWT,
+	ZodKSUID: () => ZodKSUID,
+	ZodLazy: () => ZodLazy,
+	ZodLiteral: () => ZodLiteral,
+	ZodMAC: () => ZodMAC,
+	ZodMap: () => ZodMap,
+	ZodNaN: () => ZodNaN,
+	ZodNanoID: () => ZodNanoID,
+	ZodNever: () => ZodNever,
+	ZodNonOptional: () => ZodNonOptional,
+	ZodNull: () => ZodNull,
+	ZodNullable: () => ZodNullable,
+	ZodNumber: () => ZodNumber,
+	ZodNumberFormat: () => ZodNumberFormat,
+	ZodObject: () => ZodObject,
+	ZodOptional: () => ZodOptional,
+	ZodPipe: () => ZodPipe,
+	ZodPrefault: () => ZodPrefault,
+	ZodPreprocess: () => ZodPreprocess,
+	ZodPromise: () => ZodPromise,
+	ZodReadonly: () => ZodReadonly,
+	ZodRealError: () => ZodRealError,
+	ZodRecord: () => ZodRecord,
+	ZodSet: () => ZodSet,
+	ZodString: () => ZodString,
+	ZodStringFormat: () => ZodStringFormat,
+	ZodSuccess: () => ZodSuccess,
+	ZodSymbol: () => ZodSymbol,
+	ZodTemplateLiteral: () => ZodTemplateLiteral,
+	ZodTransform: () => ZodTransform,
+	ZodTuple: () => ZodTuple,
+	ZodType: () => ZodType,
+	ZodULID: () => ZodULID,
+	ZodURL: () => ZodURL,
+	ZodUUID: () => ZodUUID,
+	ZodUndefined: () => ZodUndefined,
+	ZodUnion: () => ZodUnion,
+	ZodUnknown: () => ZodUnknown,
+	ZodVoid: () => ZodVoid,
+	ZodXID: () => ZodXID,
+	ZodXor: () => ZodXor,
+	_ZodString: () => _ZodString,
+	_default: () => _default,
+	_function: () => _function,
+	any: () => any,
+	array: () => array,
+	base64: () => base64,
+	base64url: () => base64url,
+	bigint: () => bigint$1,
+	boolean: () => boolean$1,
+	catch: () => _catch,
+	check: () => check,
+	cidrv4: () => cidrv4,
+	cidrv6: () => cidrv6,
+	clone: () => clone,
+	codec: () => codec,
+	coerce: () => coerce_exports,
+	config: () => config,
+	core: () => core_exports,
+	cuid: () => cuid,
+	cuid2: () => cuid2,
+	custom: () => custom,
+	date: () => date$1,
+	decode: () => decode,
+	decodeAsync: () => decodeAsync,
+	describe: () => describe,
+	discriminatedUnion: () => discriminatedUnion,
+	e164: () => e164,
+	email: () => email,
+	emoji: () => emoji,
+	encode: () => encode,
+	encodeAsync: () => encodeAsync,
+	endsWith: () => _endsWith,
+	enum: () => _enum,
+	exactOptional: () => exactOptional,
+	file: () => file,
+	flattenError: () => flattenError,
+	float32: () => float32,
+	float64: () => float64,
+	formatError: () => formatError,
+	fromJSONSchema: () => fromJSONSchema,
+	function: () => _function,
+	getErrorMap: () => getErrorMap,
+	globalRegistry: () => globalRegistry,
+	gt: () => _gt,
+	gte: () => _gte,
+	guid: () => guid,
+	hash: () => hash,
+	hex: () => hex,
+	hostname: () => hostname,
+	httpUrl: () => httpUrl,
+	includes: () => _includes,
+	instanceof: () => _instanceof,
+	int: () => int,
+	int32: () => int32,
+	int64: () => int64,
+	intersection: () => intersection,
+	invertCodec: () => invertCodec,
+	ipv4: () => ipv4,
+	ipv6: () => ipv6,
+	iso: () => iso_exports,
+	json: () => json,
+	jwt: () => jwt,
+	keyof: () => keyof,
+	ksuid: () => ksuid,
+	lazy: () => lazy,
+	length: () => _length,
+	literal: () => literal,
+	locales: () => locales_exports,
+	looseObject: () => looseObject,
+	looseRecord: () => looseRecord,
+	lowercase: () => _lowercase,
+	lt: () => _lt,
+	lte: () => _lte,
+	mac: () => mac,
+	map: () => map,
+	maxLength: () => _maxLength,
+	maxSize: () => _maxSize,
+	meta: () => meta,
+	mime: () => _mime,
+	minLength: () => _minLength,
+	minSize: () => _minSize,
+	multipleOf: () => _multipleOf,
+	nan: () => nan,
+	nanoid: () => nanoid,
+	nativeEnum: () => nativeEnum,
+	negative: () => _negative,
+	never: () => never,
+	nonnegative: () => _nonnegative,
+	nonoptional: () => nonoptional,
+	nonpositive: () => _nonpositive,
+	normalize: () => _normalize,
+	null: () => _null,
+	nullable: () => nullable,
+	nullish: () => nullish,
+	number: () => number$1,
+	object: () => object,
+	optional: () => optional,
+	overwrite: () => _overwrite,
+	parse: () => parse,
+	parseAsync: () => parseAsync,
+	partialRecord: () => partialRecord,
+	pipe: () => pipe,
+	positive: () => _positive,
+	prefault: () => prefault,
+	preprocess: () => preprocess,
+	prettifyError: () => prettifyError,
+	promise: () => promise,
+	property: () => _property,
+	readonly: () => readonly,
+	record: () => record,
+	refine: () => refine,
+	regex: () => _regex,
+	regexes: () => regexes_exports,
+	registry: () => registry,
+	safeDecode: () => safeDecode,
+	safeDecodeAsync: () => safeDecodeAsync,
+	safeEncode: () => safeEncode,
+	safeEncodeAsync: () => safeEncodeAsync,
+	safeParse: () => safeParse,
+	safeParseAsync: () => safeParseAsync,
+	set: () => set,
+	setErrorMap: () => setErrorMap,
+	size: () => _size,
+	slugify: () => _slugify,
+	startsWith: () => _startsWith,
+	strictObject: () => strictObject,
+	string: () => string$1,
+	stringFormat: () => stringFormat,
+	stringbool: () => stringbool,
+	success: () => success,
+	superRefine: () => superRefine,
+	symbol: () => symbol,
+	templateLiteral: () => templateLiteral,
+	toJSONSchema: () => toJSONSchema,
+	toLowerCase: () => _toLowerCase,
+	toUpperCase: () => _toUpperCase,
+	transform: () => transform,
+	treeifyError: () => treeifyError,
+	trim: () => _trim,
+	tuple: () => tuple,
+	uint32: () => uint32,
+	uint64: () => uint64,
+	ulid: () => ulid,
+	undefined: () => _undefined,
+	union: () => union,
+	unknown: () => unknown,
+	uppercase: () => _uppercase,
+	url: () => url,
+	util: () => util_exports,
+	uuid: () => uuid,
+	uuidv4: () => uuidv4,
+	uuidv6: () => uuidv6,
+	uuidv7: () => uuidv7,
+	void: () => _void,
+	xid: () => xid,
+	xor: () => xor
+});
+config(en_default());
+
+//#endregion
+//#region ../api-contract/dist/openapi.mjs
+var import_dist = require_dist();
+(0, import_dist.extendZodWithOpenApi)(external_exports);
+
+//#endregion
+//#region ../api-contract/dist/errors.mjs
+/**
+* Error shape returned by every `/api/v1` machine operation (and by the shared
+* auth guard). Each operation registers its own error schema component in the
+* OpenAPI document, so this is a factory rather than a single shared instance.
+*/
+function createApiErrorResponseSchema() {
+	return object({
+		error: string$1(),
+		issues: array(unknown()).optional()
+	});
+}
+const apiErrorResponseSchema = createApiErrorResponseSchema();
+/**
+* Canonical error codes for the `/api/v1` resource operations. Machine
+* operations keep the flat `{ error: string }` shape above unchanged; the
+* nested envelope below applies to resource operations only.
+*/
+const resourceErrorCodeSchema = _enum([
+	"bad_request",
+	"unauthenticated",
+	"forbidden",
+	"machine_locked",
+	"not_found",
+	"conflict",
+	"payload_too_large",
+	"rate_limited",
+	"capability_disabled",
+	"upstream_error",
+	"internal_error"
+]);
+/** Factory, matching `createApiErrorResponseSchema`, for per-route OpenAPI components. */
+function createResourceApiErrorResponseSchema() {
+	return object({ error: object({
+		code: resourceErrorCodeSchema,
+		message: string$1(),
+		issues: array(unknown()).optional(),
+		retryable: boolean$1().optional()
+	}) });
+}
+const resourceApiErrorResponseSchema = createResourceApiErrorResponseSchema();
+
+//#endregion
+//#region ../api-contract/dist/xgraph.mjs
+const looseRecordSchema = record(string$1(), unknown());
+const pointSchema = object({
+	x: number$1(),
+	y: number$1()
+});
+const graphModeSchema = _enum([
+	"directed",
+	"undirected",
+	"bidirectional"
+]);
+const nodeDataSchema = looseRecordSchema.refine((data) => !("parentId" in data), "XGraph node data must not contain parentId; use node.parentId.");
+const xgraphNodeSchema = object({
+	id: string$1(),
+	type: string$1().optional(),
+	parentId: string$1().nullable().optional(),
+	sourceId: string$1().optional(),
+	targetId: string$1().optional(),
+	label: string$1().nullable().optional(),
+	data: nodeDataSchema.optional(),
+	x: number$1().optional(),
+	y: number$1().optional(),
+	width: number$1().optional(),
+	height: number$1().optional(),
+	position: pointSchema.optional(),
+	dx: number$1().optional(),
+	dy: number$1().optional()
+}).passthrough();
+const xgraphEdgeSchema = object({
+	id: string$1(),
+	type: string$1().optional(),
+	sourceId: string$1(),
+	targetId: string$1(),
+	mode: graphModeSchema.optional(),
+	label: string$1().nullable().optional(),
+	data: unknown().optional(),
+	x: number$1().optional(),
+	y: number$1().optional(),
+	width: number$1().optional(),
+	height: number$1().optional(),
+	position: pointSchema.optional(),
+	dx: number$1().optional(),
+	dy: number$1().optional()
+}).passthrough();
+/** XGraph wire shape accepted and emitted at API boundaries. */
+const xgraphSchema = object({
+	xgraphSchemaVersion: literal("1.0.0").optional(),
+	id: string$1().optional(),
+	type: string$1().optional(),
+	mode: graphModeSchema.optional(),
+	parentId: string$1().nullable().optional(),
+	initialNodeId: string$1().nullable().optional(),
+	nodes: array(xgraphNodeSchema),
+	edges: array(xgraphEdgeSchema),
+	data: unknown().optional(),
+	layout: unknown().nullable().optional(),
+	annotations: array(unknown()).optional(),
+	direction: _enum([
+		"up",
+		"down",
+		"left",
+		"right"
+	]).optional(),
+	style: looseRecordSchema.optional()
+}).passthrough();
+
+//#endregion
+//#region ../api-contract/dist/resources.mjs
+/**
+* Canonical schemas for persistent `/api/v1` resources plus the owned,
+* deterministic code-extraction operation.
+*
+* These models are canonical, not upstream-shaped: providers (e.g. the Stately
+* Registry adapter) are responsible for translating upstream envelopes,
+* identifier quirks and casing into these shapes. No `{ data }` envelope
+* appears anywhere; all timestamps are ISO strings.
+*/
+/**
+* XState major versions the editor targets (see
+* `packages/editor/src/formats/xstate.ts`).
+*/
+const xstateVersionSchema = union([literal(5), literal(6)]);
+const projectVisibilitySchema = _enum([
+	"public",
+	"unlisted",
+	"private"
+]);
+const verifyResultSchema = object({
+	valid: literal(true),
+	tokenScope: _enum(["user", "project"])
+});
+/**
+* Entitlements for the authenticated caller.
+*
+* Internal contract: this is not published as an `/api/v1` operation. Editor
+* feature gating resolves it server-side through the resource provider and
+* hands the mapped result to the client (see
+* `packages/editor/src/entitlements`).
+*
+* `entitlements` is an open set of provider-defined strings; unknown values are
+* ignored rather than rejected.
+*/
+const entitlementsResultSchema = object({
+	subscription: object({
+		tier: string$1(),
+		status: string$1()
+	}).nullable(),
+	entitlements: array(string$1())
+});
+/**
+* Which editor format a machine's stored definition is in: `digraph` is the
+* original (legacy) editor's format, `xgraph` the current one.
+*/
+const machineDefinitionFormatSchema = _enum(["digraph", "xgraph"]);
+/**
+* `name` and timestamps are optional: some upstream project envelopes only
+* return machine ids. Providers that can supply them cheaply should.
+*/
+const projectMachineSummarySchema = object({
+	machineId: string$1(),
+	name: string$1().optional(),
+	createdAt: string$1().optional(),
+	updatedAt: string$1().optional(),
+	format: machineDefinitionFormatSchema.optional(),
+	locked: boolean$1().optional()
+});
+/**
+* A project list row. It carries the project's machine roster, not just its
+* metadata, so a client can mount a whole workspace from one `projects.list`
+* response and fetch definitions lazily.
+*/
+const projectSummarySchema = object({
+	projectId: string$1(),
+	projectVersionId: string$1(),
+	name: string$1(),
+	ownership: _enum(["personal", "team"]).optional(),
+	description: string$1().nullable(),
+	visibility: projectVisibilitySchema,
+	createdAt: string$1(),
+	updatedAt: string$1(),
+	rootMachineId: string$1().nullable().optional(),
+	machines: array(projectMachineSummarySchema).optional(),
+	permissions: object({ canEdit: boolean$1() }).optional(),
+	allowedVisibility: array(projectVisibilitySchema).optional()
+});
+const projectSchema = projectSummarySchema.extend({
+	rootMachineId: string$1().nullable(),
+	machines: array(projectMachineSummarySchema),
+	permissions: object({ canEdit: boolean$1() })
+});
+const machineSchema = object({
+	machineId: string$1(),
+	name: string$1(),
+	projectId: string$1().optional(),
+	projectVersionId: string$1(),
+	definition: unknown(),
+	graph: xgraphSchema.optional(),
+	createdAt: string$1().optional(),
+	updatedAt: string$1().optional(),
+	format: machineDefinitionFormatSchema.optional(),
+	locked: boolean$1().optional()
+});
+const machineVersionSchema = object({
+	machineVersionId: string$1(),
+	machineId: string$1(),
+	versionNumber: number$1(),
+	name: string$1(),
+	definition: unknown(),
+	createdAt: string$1(),
+	updatedAt: string$1(),
+	format: machineDefinitionFormatSchema.optional()
+});
+/** Version-history row without the definition payload. */
+const machineVersionSummarySchema = object({
+	machineVersionId: string$1(),
+	machineId: string$1(),
+	versionNumber: number$1(),
+	name: string$1().nullable(),
+	status: string$1(),
+	parentVersionId: string$1().nullable(),
+	createdAt: string$1(),
+	updatedAt: string$1(),
+	format: machineDefinitionFormatSchema.optional()
+});
+/** Result of converting a machine's stored definition to XGraph in place. */
+const machinesConvertResultSchema = object({
+	machine: machineSchema,
+	created: boolean$1(),
+	version: object({
+		machineVersionId: string$1(),
+		versionNumber: number$1(),
+		name: string$1().nullable()
+	})
+});
+/**
+* A project the caller may fork a machine into, with the version ids a fork
+* can target. `projectVersionIds` is ordered as the provider reports it.
+*/
+const projectDestinationProjectSchema = object({
+	projectId: string$1(),
+	name: string$1(),
+	visibility: projectVisibilitySchema,
+	projectVersionIds: array(string$1())
+});
+/**
+* Fork destinations grouped by owner. The caller's personal projects are one
+* owner alongside each team; `ownerId` is opaque and provider-defined.
+*/
+const projectDestinationSchema = object({
+	ownerId: string$1(),
+	name: string$1(),
+	projects: array(projectDestinationProjectSchema)
+});
+/** Result of forking a machine into a new or existing project version. */
+const machinesForkResultSchema = object({
+	machine: machineSchema,
+	projectVersionId: string$1(),
+	projectId: string$1()
+});
+/**
+* The version holding a machine's pre-conversion (legacy editor) definition.
+* `versionId` is `null` when the machine has no such version, which is the
+* signal that the legacy editor cannot be re-entered for it.
+*/
+const machineLegacyVersionSchema = object({ versionId: string$1().nullable() });
+/** Result of restoring a machine's legacy-editor definition. */
+const machinesRestoreLegacyResultSchema = object({
+	machine: machineSchema,
+	version: object({
+		machineVersionId: string$1(),
+		versionNumber: number$1(),
+		name: string$1().nullable()
+	})
+});
+/**
+* Result of restoring a machine to one of its own versions.
+*
+* `capturedVersion` is the new version holding the machine's *pre-restore*
+* definition, so the restore itself is undoable. It is `null` when the restore
+* was a no-op (the machine already held that version's definition), which is
+* the signal that no history row was added.
+*/
+const machinesRestoreVersionResultSchema = object({
+	machine: machineSchema,
+	capturedVersion: machineVersionSummarySchema.nullable()
+});
+const extractedMachinesSchema = object({ machines: array(object({
+	config: record(string$1(), unknown()),
+	machineIndex: number$1().int().nonnegative().optional()
+})) });
+const projectsCreateRequestSchema = object({
+	name: string$1().min(1),
+	visibility: projectVisibilitySchema
+});
+const projectsUpdateRequestSchema = object({
+	name: string$1().min(1).optional(),
+	description: string$1().nullable().optional(),
+	visibility: projectVisibilitySchema.optional()
+}).refine((value) => value.name !== void 0 || value.description !== void 0 || value.visibility !== void 0, { message: "At least one of `name`, `description` or `visibility` is required." });
+const machinesCreateRequestSchema = object({
+	projectVersionId: string$1().min(1),
+	xstateVersion: xstateVersionSchema,
+	name: string$1().min(1).optional(),
+	definition: unknown().optional()
+});
+const machinesUpdateRequestSchema = object({
+	name: string$1().min(1).optional(),
+	definition: unknown().optional(),
+	expectedUpdatedAt: string$1().min(1).optional()
+}).refine((value) => value.name !== void 0 || value.definition !== void 0, { message: "At least one of `name` or `definition` is required." });
+/**
+* `status` is canonical lowercase; providers map it to their own casing.
+* Omitting `definition` snapshots the machine's current definition.
+*/
+const machineVersionsCreateRequestSchema = object({
+	name: string$1().min(1).optional(),
+	definition: unknown().optional(),
+	status: _enum(["committed", "auto"]).optional(),
+	parentVersionId: string$1().min(1).optional()
+});
+const machinesConvertRequestSchema = object({
+	definition: xgraphSchema,
+	expectedUpdatedAt: string$1().min(1),
+	keepOriginalVersion: boolean$1().optional()
+});
+/**
+* Fork a machine into exactly one target: an existing project version, or a
+* new project to create for it. Both, or neither, is a client bug.
+*/
+const machinesForkRequestSchema = object({
+	targetProjectVersionId: string$1().min(1).optional(),
+	targetProject: object({
+		name: string$1().min(1),
+		visibility: projectVisibilitySchema,
+		teamId: string$1().min(1).optional()
+	}).optional(),
+	machineName: string$1().min(1).optional(),
+	xstateVersion: xstateVersionSchema.optional()
+}).refine((value) => value.targetProjectVersionId === void 0 !== (value.targetProject === void 0), { message: "Exactly one of `targetProjectVersionId` or `targetProject` is required." });
+const machinesRestoreLegacyRequestSchema = object({
+	versionId: string$1().min(1).optional(),
+	expectedUpdatedAt: string$1().min(1),
+	reason: string$1().optional()
+});
+const machinesRestoreVersionRequestSchema = object({ expectedUpdatedAt: string$1().min(1).optional() });
+const codeExtractMachinesRequestSchema = object({
+	code: string$1().min(1),
+	xstateVersion: xstateVersionSchema.optional()
+});
+const authVerifyResponseSchema = verifyResultSchema;
+const projectsListResponseSchema = array(projectSummarySchema);
+const projectsGetResponseSchema = projectSchema;
+const projectsCreateResponseSchema = projectSchema;
+const projectsUpdateResponseSchema = projectSchema;
+const projectsDeleteResponseSchema = object({ projectId: string$1() });
+const projectsListMachinesResponseSchema = array(projectMachineSummarySchema);
+const projectsDestinationsResponseSchema = array(projectDestinationSchema);
+const machinesCreateResponseSchema = machineSchema;
+const machinesGetResponseSchema = machineSchema;
+const machinesUpdateResponseSchema = machineSchema;
+const machinesGetVersionResponseSchema = machineVersionSchema;
+const machineVersionsListResponseSchema = array(machineVersionSummarySchema);
+const machineVersionsCreateResponseSchema = machineVersionSchema;
+const machinesConvertDefinitionResponseSchema = machinesConvertResultSchema;
+const machinesForkResponseSchema = machinesForkResultSchema;
+const machinesGetLegacyVersionResponseSchema = machineLegacyVersionSchema;
+const machinesRestoreLegacyResponseSchema = machinesRestoreLegacyResultSchema;
+const machinesRestoreVersionResponseSchema = machinesRestoreVersionResultSchema;
+const codeExtractMachinesResponseSchema = extractedMachinesSchema;
+/**
+* Request/response schema pairs keyed by resource capability name. Kept here
+* rather than on the `Capability` metadata entries so that the capability
+* registry stays plain, serialisable data.
+*/
+const resourceOperationSchemas = {
+	"auth.verify": { response: authVerifyResponseSchema },
+	"projects.list": { response: projectsListResponseSchema },
+	"projects.create": {
+		request: projectsCreateRequestSchema,
+		response: projectsCreateResponseSchema
+	},
+	"projects.get": { response: projectsGetResponseSchema },
+	"projects.update": {
+		request: projectsUpdateRequestSchema,
+		response: projectsUpdateResponseSchema
+	},
+	"projects.delete": { response: projectsDeleteResponseSchema },
+	"projects.listMachines": { response: projectsListMachinesResponseSchema },
+	"projects.destinations": { response: projectsDestinationsResponseSchema },
+	"machines.create": {
+		request: machinesCreateRequestSchema,
+		response: machinesCreateResponseSchema
+	},
+	"machines.get": { response: machinesGetResponseSchema },
+	"machines.getVersion": { response: machinesGetVersionResponseSchema },
+	"machines.update": {
+		request: machinesUpdateRequestSchema,
+		response: machinesUpdateResponseSchema
+	},
+	"machines.versions.list": { response: machineVersionsListResponseSchema },
+	"machines.versions.create": {
+		request: machineVersionsCreateRequestSchema,
+		response: machineVersionsCreateResponseSchema
+	},
+	"machines.convertDefinition": {
+		request: machinesConvertRequestSchema,
+		response: machinesConvertDefinitionResponseSchema
+	},
+	"machines.fork": {
+		request: machinesForkRequestSchema,
+		response: machinesForkResponseSchema
+	},
+	"machines.getLegacyVersion": { response: machinesGetLegacyVersionResponseSchema },
+	"machines.restoreLegacy": {
+		request: machinesRestoreLegacyRequestSchema,
+		response: machinesRestoreLegacyResponseSchema
+	},
+	"machines.restoreVersion": {
+		request: machinesRestoreVersionRequestSchema,
+		response: machinesRestoreVersionResponseSchema
+	}
+};
+/** Provider-independent operations implemented by this repository. */
+const codeOperationSchemas = { "code.extractMachines": {
+	request: codeExtractMachinesRequestSchema,
+	response: codeExtractMachinesResponseSchema
+} };
+/** Every owned API operation with a canonical request/response contract. */
+const operationSchemas = {
+	...resourceOperationSchemas,
+	...codeOperationSchemas
+};
+
+//#endregion
+//#region src/studio.ts
+/**
+* Remote client for the owned Stately resource contract (`/api/v1/*`).
+*
+* Every method targets our own routes (never the legacy Registry API), sends
+* JSON bodies with a bearer credential, and validates responses against the
+* canonical Zod schemas from `@statelyai/api-contract`. Responses are canonical
+* values directly: there is no `{ data }` envelope. Errors use the nested
+* envelope `{ error: { code, message, issues?, retryable? } }`.
+*/
+/** Default base URL of the editor/API deployment hosting `/api/v1`. */
+const DEFAULT_STATELY_BASE_URL = "https://editor.stately.ai";
+var StudioApiError = class extends Error {
+	status;
+	/** Canonical resource error code, when the server sent one. */
+	code;
+	issues;
+	retryable;
+	constructor(message, status, options = {}) {
+		super(message);
+		this.name = "StudioApiError";
+		this.status = status;
+		this.code = options.code;
+		this.issues = options.issues;
+		this.retryable = options.retryable;
+	}
+};
+function getFetch(fetchImpl) {
+	const resolvedFetch = fetchImpl ?? globalThis.fetch;
+	if (!resolvedFetch) throw new Error("No fetch implementation available. Pass one via createStatelyClient({ fetch }).");
+	return resolvedFetch;
+}
+function joinApiUrl(baseUrl, path) {
+	return `${baseUrl.replace(/\/+$/, "")}/api/v1${path}`;
+}
+async function parseJson(response) {
+	if (!response.headers.get("content-type")?.includes("application/json")) return null;
+	return response.json().catch(() => null);
+}
+function toApiError(data, status) {
+	const parsed = resourceApiErrorResponseSchema.safeParse(data);
+	if (parsed.success) {
+		const { code, message, issues, retryable } = parsed.data.error;
+		return new StudioApiError(message, status, {
+			code,
+			issues,
+			retryable
+		});
+	}
+	if (typeof data === "object" && data !== null && "error" in data && typeof data.error === "string") return new StudioApiError(data.error, status);
+	return new StudioApiError(`HTTP ${status}`, status);
+}
+function normalizeVisibility(visibility) {
+	return visibility.toLowerCase();
+}
+function normalizeXStateVersion(xstateVersion) {
+	return xstateVersion === void 0 || xstateVersion === 4 ? 5 : xstateVersion;
+}
+function normalizeExtractXStateVersion(xstateVersion) {
+	return xstateVersion === 4 ? 5 : xstateVersion;
+}
+function withMachineAlias(machine) {
+	return {
+		...machine,
+		definition: machine.definition,
+		id: machine.machineId
+	};
+}
+function withProjectAlias(project) {
+	return {
+		...project,
+		id: project.projectVersionId
+	};
+}
+function isCredentialLike(value) {
+	if (typeof value === "string") return true;
+	return typeof value === "object" && value !== null && "type" in value && (value.type === "api_key" || value.type === "oauth");
+}
+function createStatelyClient(options = {}) {
+	const baseUrl = options.baseUrl ?? DEFAULT_STATELY_BASE_URL;
+	const fetchImpl = getFetch(options.fetch);
+	const defaultCredential = options.credential ?? (options.apiKey ? {
+		type: "api_key",
+		token: options.apiKey
+	} : void 0);
+	const defaultAuthMode = options.authMode ?? "auto";
+	async function request(path, init, schema, requestOptions = {}) {
+		const headers = new Headers(init.headers);
+		const authMode = requestOptions.authMode ?? defaultAuthMode;
+		const credential = requestOptions.credential ?? defaultCredential;
+		if (authMode !== "none") {
+			const token = getCredentialToken(credential);
+			if (authMode === "bearer" && (!token || !credential)) throw new StudioApiError("No Stately credential configured. Pass createStatelyClient({ credential }) or use authMode: \"auto\" to let the server decide whether authentication is required.", 401, { code: "unauthenticated" });
+			if (token && credential) headers.set("Authorization", createAuthorizationHeader(credential));
+		}
+		const response = await fetchImpl(joinApiUrl(baseUrl, path), {
+			...init,
+			headers,
+			...requestOptions.signal ? { signal: requestOptions.signal } : {}
+		});
+		const data = await parseJson(response);
+		if (!response.ok) throw toApiError(data, response.status);
+		const parsed = schema.safeParse(data);
+		if (!parsed.success) throw new StudioApiError(`Unexpected response for ${path}: ${parsed.error.message}`, response.status, {
+			code: "internal_error",
+			issues: [...parsed.error.issues]
+		});
+		return parsed.data;
+	}
+	function jsonInit(method, body) {
+		return {
+			method,
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		};
+	}
+	const projects = {
+		list(requestOptions) {
+			return request("/projects", { method: "GET" }, projectsListResponseSchema, requestOptions);
+		},
+		create(input, requestOptions) {
+			return request("/projects", jsonInit("POST", {
+				name: input.name,
+				visibility: normalizeVisibility(input.visibility)
+			}), projectSchema, requestOptions).then(withProjectAlias);
+		},
+		get(projectId, requestOptions) {
+			return request(`/projects/${encodeURIComponent(projectId)}`, { method: "GET" }, projectSchema, requestOptions).then(withProjectAlias);
+		},
+		update(projectId, input, requestOptions) {
+			return request(`/projects/${encodeURIComponent(projectId)}`, jsonInit("PATCH", {
+				...input.name !== void 0 ? { name: input.name } : {},
+				...input.description !== void 0 ? { description: input.description } : {},
+				...input.visibility !== void 0 ? { visibility: normalizeVisibility(input.visibility) } : {}
+			}), projectSchema, requestOptions).then(withProjectAlias);
+		},
+		delete(projectId, requestOptions) {
+			return request(`/projects/${encodeURIComponent(projectId)}`, { method: "DELETE" }, projectsDeleteResponseSchema, requestOptions);
+		},
+		listMachines(projectId, requestOptions) {
+			return request(`/projects/${encodeURIComponent(projectId)}/machines`, { method: "GET" }, projectsListMachinesResponseSchema, requestOptions);
+		},
+		async ensure(input, requestOptions) {
+			if (input.matchConnectedRepo !== false) {
+				const match = (await projects.list(requestOptions)).find((candidate) => candidate.name === input.name);
+				if (match) return projects.get(match.projectId, requestOptions);
+			}
+			return projects.create(input, requestOptions);
+		}
+	};
+	const machines = {
+		create(input, requestOptions) {
+			return request("/machines", jsonInit("POST", {
+				projectVersionId: input.projectVersionId,
+				xstateVersion: normalizeXStateVersion(input.xstateVersion),
+				...input.name !== void 0 ? { name: input.name } : {},
+				...input.definition !== void 0 ? { definition: input.definition } : {}
+			}), machineSchema, requestOptions).then((machine) => withMachineAlias(machine));
+		},
+		async createMany(input, requestOptions) {
+			return [await machines.create(input, requestOptions)];
+		},
+		get(machineId, getOptions = {}) {
+			return request(`/machines/${encodeURIComponent(machineId)}`, { method: "GET" }, machineSchema, getOptions).then((machine) => withMachineAlias(machine));
+		},
+		getVersion(machineId, versionId, requestOptions) {
+			return request(`/machines/${encodeURIComponent(machineId)}/versions/${encodeURIComponent(versionId)}`, { method: "GET" }, machineVersionSchema, requestOptions);
+		},
+		update(machineIdOrInput, inputOrOptions, maybeOptions) {
+			const machineId = typeof machineIdOrInput === "string" ? machineIdOrInput : machineIdOrInput.machineId ?? machineIdOrInput.id;
+			if (!machineId) throw new StudioApiError("machines.update requires a machine id.", 400, { code: "bad_request" });
+			const input = (typeof machineIdOrInput === "string" ? inputOrOptions : machineIdOrInput) ?? {};
+			const requestOptions = typeof machineIdOrInput === "string" ? maybeOptions : inputOrOptions;
+			return request(`/machines/${encodeURIComponent(machineId)}`, jsonInit("PATCH", {
+				...input.name !== void 0 ? { name: input.name } : {},
+				...input.definition !== void 0 ? { definition: input.definition } : {},
+				...input.expectedUpdatedAt !== void 0 ? { expectedUpdatedAt: input.expectedUpdatedAt } : {}
+			}), machineSchema, requestOptions).then((machine) => withMachineAlias(machine));
+		}
+	};
+	return {
+		auth: { verify(credentialOrOptions, verifyOptions) {
+			return request("/auth/verify", { method: "GET" }, verifyResultSchema, isCredentialLike(credentialOrOptions) ? {
+				...verifyOptions,
+				credential: credentialOrOptions
+			} : credentialOrOptions ?? verifyOptions ?? {});
+		} },
+		projects,
+		machines,
+		code: { extractMachines(codeOrInput, extractOptions = {}) {
+			const input = typeof codeOrInput === "string" ? {
+				code: codeOrInput,
+				xstateVersion: extractOptions.xstateVersion
+			} : codeOrInput;
+			const legacyOptions = extractOptions;
+			const credential = legacyOptions.credential ?? (legacyOptions.apiKey ? {
+				type: "api_key",
+				token: legacyOptions.apiKey
+			} : void 0);
+			return request("/code/extract-machines", jsonInit("POST", {
+				code: input.code,
+				xstateVersion: normalizeExtractXStateVersion(input.xstateVersion)
+			}), extractedMachinesSchema, {
+				...extractOptions,
+				credential
+			});
+		} }
+	};
+}
+
+//#endregion
+export { StudioApiError as n, createStatelyClient as r, DEFAULT_STATELY_BASE_URL as t };