@soat/sdk 0.6.5 → 0.6.10

package/dist/index.cjs

@@ -0,0 +1,2712 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/generated/core/bodySerializer.gen.ts
+const serializeFormDataPair = (data, key, value) => {
+	if (typeof value === "string" || value instanceof Blob) data.append(key, value);
+	else if (value instanceof Date) data.append(key, value.toISOString());
+	else data.append(key, JSON.stringify(value));
+};
+const formDataBodySerializer = { bodySerializer: (body) => {
+	const data = new FormData();
+	Object.entries(body).forEach(([key, value]) => {
+		if (value === void 0 || value === null) return;
+		if (Array.isArray(value)) value.forEach((v) => serializeFormDataPair(data, key, v));
+		else serializeFormDataPair(data, key, value);
+	});
+	return data;
+} };
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+Object.entries({
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query"
+});
+//#endregion
+//#region src/generated/core/serverSentEvents.gen.ts
+function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const requestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) request = await onRequest(url, requestInit);
+				const response = await (options.fetch ?? globalThis.fetch)(request);
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						buffer = buffer.replace(/\r\n?/g, "\n");
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				await sleep(Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4));
+			}
+		}
+	};
+	return { stream: createStream() };
+}
+//#endregion
+//#region src/generated/core/pathSerializer.gen.ts
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+//#endregion
+//#region src/generated/core/utils.gen.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+function getValidRequestBody(options) {
+	const hasBody = options.body !== void 0;
+	if (hasBody && options.bodySerializer) {
+		if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
+}
+//#endregion
+//#region src/generated/core/auth.gen.ts
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+//#endregion
+//#region src/generated/client/utils.gen.ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			const options = parameters[name] || args;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...options.array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...options.object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved: options.allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+/**
+* Infers parseAs value from provided Content-Type header.
+*/
+const getParseAs = (contentType) => {
+	if (!contentType) return "stream";
+	const cleanContent = contentType.split(";")[0]?.trim();
+	if (!cleanContent) return;
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
+	if (cleanContent === "multipart/form-data") return "formData";
+	if ([
+		"application/",
+		"audio/",
+		"image/",
+		"video/"
+	].some((type) => cleanContent.startsWith(type))) return "blob";
+	if (cleanContent.startsWith("text/")) return "text";
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
+	return false;
+};
+async function setAuthParams(options) {
+	for (const auth of options.security ?? []) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			default:
+				options.headers.set(name, token);
+				break;
+		}
+	}
+}
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+const headersEntries = (headers) => {
+	const entries = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) continue;
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	fns = [];
+	clear() {
+		this.fns = [];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) this.fns[index] = null;
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this.fns[id] ? id : -1;
+		return this.fns.indexOf(id);
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+	use(fn) {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+//#endregion
+//#region src/generated/client/client.gen.ts
+const createClient = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams(opts);
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body !== void 0 && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
+		if (opts.body === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
+		const resolvedOpts = opts;
+		return {
+			opts: resolvedOpts,
+			url: buildUrl(resolvedOpts)
+		};
+	};
+	const request = async (options) => {
+		const throwOnError = options.throwOnError ?? _config.throwOnError;
+		const responseStyle = options.responseStyle ?? _config.responseStyle;
+		let request;
+		let response;
+		try {
+			const { opts, url } = await beforeRequest(options);
+			const requestInit = {
+				redirect: "follow",
+				...opts,
+				body: getValidRequestBody(opts)
+			};
+			request = new Request(url, requestInit);
+			for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+			const _fetch = opts.fetch;
+			response = await _fetch(request);
+			for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request, opts);
+			const result = {
+				request,
+				response
+			};
+			if (response.ok) {
+				const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+				if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+					let emptyData;
+					switch (parseAs) {
+						case "arrayBuffer":
+						case "blob":
+						case "text":
+							emptyData = await response[parseAs]();
+							break;
+						case "formData":
+							emptyData = new FormData();
+							break;
+						case "stream":
+							emptyData = response.body;
+							break;
+						default:
+							emptyData = {};
+							break;
+					}
+					return opts.responseStyle === "data" ? emptyData : {
+						data: emptyData,
+						...result
+					};
+				}
+				let data;
+				switch (parseAs) {
+					case "arrayBuffer":
+					case "blob":
+					case "formData":
+					case "text":
+						data = await response[parseAs]();
+						break;
+					case "json": {
+						const text = await response.text();
+						data = text ? JSON.parse(text) : {};
+						break;
+					}
+					case "stream": return opts.responseStyle === "data" ? response.body : {
+						data: response.body,
+						...result
+					};
+				}
+				if (parseAs === "json") {
+					if (opts.responseValidator) await opts.responseValidator(data);
+					if (opts.responseTransformer) data = await opts.responseTransformer(data);
+				}
+				return opts.responseStyle === "data" ? data : {
+					data,
+					...result
+				};
+			}
+			const textError = await response.text();
+			let jsonError;
+			try {
+				jsonError = JSON.parse(textError);
+			} catch {}
+			throw jsonError ?? textError;
+		} catch (error) {
+			let finalError = error;
+			for (const fn of interceptors.error.fns) if (fn) finalError = await fn(finalError, response, request, options);
+			finalError = finalError || {};
+			if (throwOnError) throw finalError;
+			return responseStyle === "data" ? void 0 : {
+				error: finalError,
+				request,
+				response
+			};
+		}
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			method,
+			onRequest: async (url, init) => {
+				let request = new Request(url, init);
+				for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+				return request;
+			},
+			serializedBody: getValidRequestBody(opts),
+			url
+		});
+	};
+	const _buildUrl = (options) => buildUrl({
+		..._config,
+		...options
+	});
+	return {
+		buildUrl: _buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		interceptors,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE")
+		},
+		trace: makeMethodFn("TRACE")
+	};
+};
+//#endregion
+//#region src/generated/client.gen.ts
+const client = createClient(createConfig());
+//#endregion
+//#region src/generated/sdk.gen.ts
+var Actors = class {
+	/**
+	* List actors
+	*
+	* Returns all actors the caller has access to. If projectId is provided, returns only actors in that project. project keys are scoped to a single project automatically. JWT users without projectId receive actors across all their accessible projects.
+	*/
+	static listActors(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/actors",
+			...options
+		});
+	}
+	/**
+	* Create an actor
+	*
+	* Creates a new actor. project keys automatically infer the project from the key's scope; JWT callers must supply projectId.
+	*/
+	static createActor(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/actors",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete an actor
+	*
+	* Deletes an actor by its ID
+	*/
+	static deleteActor(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/actors/{actor_id}",
+			...options
+		});
+	}
+	/**
+	* Get an actor by ID
+	*
+	* Returns an actor by its ID
+	*/
+	static getActor(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/actors/{actor_id}",
+			...options
+		});
+	}
+	/**
+	* Update an actor
+	*
+	* Updates an actor's properties
+	*/
+	static updateActor(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/actors/{actor_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get actor tags
+	*
+	* Returns all tags attached to the actor
+	*/
+	static getActorTags(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/actors/{actor_id}/tags",
+			...options
+		});
+	}
+	/**
+	* Merge actor tags
+	*
+	* Merges provided tags with existing tags (existing tags are preserved unless overridden)
+	*/
+	static mergeActorTags(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/actors/{actor_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Replace actor tags
+	*
+	* Replaces all tags on the actor with the provided tags (not merged)
+	*/
+	static replaceActorTags(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/actors/{actor_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Agents = class {
+	/**
+	* List agents
+	*
+	* Returns all agents in the project.
+	*/
+	static listAgents(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/agents",
+			...options
+		});
+	}
+	/**
+	* Create an agent
+	*
+	* Creates a new agent bound to an AI provider.
+	*/
+	static createAgent(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/agents",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete an agent
+	*
+	* Deletes an agent by ID.
+	*/
+	static deleteAgent(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/agents/{agent_id}",
+			...options
+		});
+	}
+	/**
+	* Get an agent
+	*
+	* Returns a single agent by ID.
+	*/
+	static getAgent(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/agents/{agent_id}",
+			...options
+		});
+	}
+	/**
+	* Update an agent
+	*
+	* Updates an existing agent.
+	*/
+	static updateAgent(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/agents/{agent_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Run an agent generation
+	*
+	* Sends messages to the agent, resolves its tools, and runs the AI model loop. Supports streaming via `stream: true`. Client tools pause the generation and return `requires_action`.
+	*
+	*/
+	static createAgentGeneration(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/agents/{agent_id}/generate",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Submit tool outputs for a paused generation
+	*
+	* Resumes a generation that was paused due to client tool calls. Provide tool outputs for each pending tool call.
+	*
+	*/
+	static submitAgentToolOutputs(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/agents/{agent_id}/generate/{generation_id}/tool-outputs",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Create an actor for an agent
+	*
+	* Creates a new actor associated with the specified agent
+	*/
+	static createAgentActor(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/agents/{agent_id}/actors",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var AiProviders = class {
+	/**
+	* List AI providers
+	*
+	* Returns a list of AI provider configurations for a project
+	*/
+	static listAiProviders(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/ai-providers",
+			...options
+		});
+	}
+	/**
+	* Create an AI provider
+	*
+	* Creates a new LLM provider configuration
+	*/
+	static createAiProvider(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/ai-providers",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete an AI provider
+	*
+	* Deletes an AI provider configuration
+	*/
+	static deleteAiProvider(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/ai-providers/{ai_provider_id}",
+			...options
+		});
+	}
+	/**
+	* Get an AI provider
+	*
+	* Returns a specific AI provider configuration
+	*/
+	static getAiProvider(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/ai-providers/{ai_provider_id}",
+			...options
+		});
+	}
+	/**
+	* Update an AI provider
+	*
+	* Updates an AI provider configuration
+	*/
+	static updateAiProvider(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/ai-providers/{ai_provider_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var ApiKeys = class {
+	/**
+	* List API keys
+	*
+	* Lists API keys accessible to the caller. - JWT admin: returns all API keys. - JWT regular user: returns only the user's own API keys. - API key scoped to a project: returns only API keys scoped to that project.
+	*
+	*/
+	static listApiKeys(options) {
+		return (options?.client ?? client).get({
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/v1/api-keys",
+			...options
+		});
+	}
+	/**
+	* Create an API key
+	*
+	* Creates a new API key for the authenticated user. - If `project_id` is provided, the key is scoped to that project. - If `policy_ids` is provided, the key's effective permissions are the intersection of the user's policies and the key's policies. - If neither is provided, the key inherits the user's full permissions.
+	*
+	*/
+	static createApiKey(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/api-keys",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete an API key
+	*
+	* Deletes an API key. Only the owner or an admin can delete it.
+	*/
+	static deleteApiKey(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/api-keys/{api_key_id}",
+			...options
+		});
+	}
+	/**
+	* Get an API key
+	*
+	* Returns details of an API key. Only the owner or an admin can access it.
+	*/
+	static getApiKey(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/api-keys/{api_key_id}",
+			...options
+		});
+	}
+	/**
+	* Update an API key
+	*
+	* Updates an API key's name, project scope, or policies. Only the owner or an admin can update it.
+	*/
+	static updateApiKey(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/api-keys/{api_key_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Chats = class {
+	/**
+	* List chats
+	*
+	* Returns all chats in the project.
+	*/
+	static listChats(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/chats",
+			...options
+		});
+	}
+	/**
+	* Create a chat
+	*
+	* Creates a new chat resource bound to an AI provider.
+	*/
+	static createChat(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/chats",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a chat
+	*
+	* Deletes a chat by ID.
+	*/
+	static deleteChat(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/chats/{chat_id}",
+			...options
+		});
+	}
+	/**
+	* Get a chat
+	*
+	* Returns a single chat by ID.
+	*/
+	static getChat(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/chats/{chat_id}",
+			...options
+		});
+	}
+	/**
+	* Create a chat completion for a stored chat
+	*
+	* Runs a completion using the AI provider and settings stored in the chat. Pass `stream: true` for SSE streaming. A system message in `messages` overrides the chat's stored system message for this call only. Messages may use `documentId` instead of `content`.
+	*
+	*/
+	static createChatCompletionForChat(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/chats/{chat_id}/completions",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Create a chat completion (stateless)
+	*
+	* OpenAI Chat Completions-compatible endpoint. Resolves the AI provider from `ai_provider_id`, decrypts its secret, and calls the appropriate Vercel AI SDK provider. `ai_provider_id` is required — there is no server-side model fallback.
+	*
+	*/
+	static createChatCompletion(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/chats/completions",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Create an actor for a chat
+	*
+	* Creates a new actor associated with the specified chat
+	*/
+	static createChatActor(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/chats/{chat_id}/actors",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Conversations = class {
+	/**
+	* List conversations
+	*
+	* Returns all conversations the caller has access to. If projectId is provided, returns only conversations in that project. project keys are scoped to a single project automatically.
+	*/
+	static listConversations(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/conversations",
+			...options
+		});
+	}
+	/**
+	* Create a conversation
+	*
+	* Creates a new conversation. project keys automatically infer the project from the key's scope; JWT callers must supply projectId.
+	*/
+	static createConversation(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/conversations",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a conversation
+	*
+	* Deletes a conversation by its ID
+	*/
+	static deleteConversation(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/conversations/{conversation_id}",
+			...options
+		});
+	}
+	/**
+	* Get a conversation by ID
+	*
+	* Returns a conversation by its ID
+	*/
+	static getConversation(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/conversations/{conversation_id}",
+			...options
+		});
+	}
+	/**
+	* Update a conversation
+	*
+	* Updates the status of a conversation
+	*/
+	static updateConversation(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/conversations/{conversation_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List conversation messages
+	*
+	* Returns all messages (documents) attached to a conversation, ordered by position
+	*/
+	static listConversationMessages(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/conversations/{conversation_id}/messages",
+			...options
+		});
+	}
+	/**
+	* Add a message to a conversation
+	*
+	* Creates a document from the message text and attaches it to the conversation at the given position. If position is omitted, it is appended at the end.
+	*/
+	static addConversationMessage(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/conversations/{conversation_id}/messages",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Generate the next message in a conversation
+	*
+	* Generates the next message using the specified actor's linked agent or chat.
+	* On `completed`, the reply is persisted as a new ConversationMessage authored
+	* by that actor. On `requires_action`, nothing is persisted; the caller must
+	* submit tool outputs via the Agents module and re-invoke generate.
+	*
+	*/
+	static generateConversationMessage(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/conversations/{conversation_id}/generate",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List actors in a conversation
+	*
+	* Returns all distinct actors who have sent at least one message in the conversation
+	*/
+	static listConversationActors(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/conversations/{conversation_id}/actors",
+			...options
+		});
+	}
+	/**
+	* Remove a message from a conversation
+	*
+	* Removes a document from a conversation
+	*/
+	static removeConversationMessage(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/conversations/{conversation_id}/messages/{document_id}",
+			...options
+		});
+	}
+	/**
+	* Get conversation tags
+	*
+	* Returns all tags attached to the conversation
+	*/
+	static getConversationTags(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/conversations/{conversation_id}/tags",
+			...options
+		});
+	}
+	/**
+	* Merge conversation tags
+	*
+	* Merges provided tags with existing tags
+	*/
+	static mergeConversationTags(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/conversations/{conversation_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Replace conversation tags
+	*
+	* Replaces all tags on the conversation with the provided tags
+	*/
+	static replaceConversationTags(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/conversations/{conversation_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Documents = class {
+	/**
+	* List documents
+	*
+	* Returns all documents the caller has access to. If projectId is provided, returns only documents in that project. project keys are scoped to a single project automatically. JWT users without projectId receive documents across all their accessible projects.
+	*/
+	static listDocuments(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/documents",
+			...options
+		});
+	}
+	/**
+	* Create a document
+	*
+	* Creates a new text document and generates an embedding vector for semantic search. project keys automatically infer the project from the key's scope; JWT callers must supply projectId.
+	*/
+	static createDocument(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/documents",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a document
+	*
+	* Deletes a document and its underlying file
+	*/
+	static deleteDocument(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/documents/{document_id}",
+			...options
+		});
+	}
+	/**
+	* Get a document by ID
+	*
+	* Returns a document with its text content
+	*/
+	static getDocument(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/documents/{document_id}",
+			...options
+		});
+	}
+	/**
+	* Update a document
+	*
+	* Updates document content, title, path, metadata, or tags. Supplying `path` moves the document to a new logical path within the project.
+	*/
+	static updateDocument(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/documents/{document_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get document tags
+	*
+	* Returns all tags attached to the document
+	*/
+	static getDocumentTags(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/documents/{document_id}/tags",
+			...options
+		});
+	}
+	/**
+	* Merge document tags
+	*
+	* Merges provided tags with existing tags (existing tags are preserved unless overridden)
+	*/
+	static mergeDocumentTags(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/documents/{document_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Replace document tags
+	*
+	* Replaces all tags on the document with the provided tags (not merged)
+	*/
+	static replaceDocumentTags(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/documents/{document_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Files = class {
+	/**
+	* List all files
+	*
+	* Returns a list of all stored files
+	*/
+	static listFiles(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/files",
+			...options
+		});
+	}
+	/**
+	* Create a file
+	*
+	* Creates a new file record in the system
+	*/
+	static createFile(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/files",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Upload a file
+	*
+	* Uploads a file to the server and stores it in the configured storage directory
+	*/
+	static uploadFile(options) {
+		return (options.client ?? client).post({
+			...formDataBodySerializer,
+			url: "/api/v1/files/upload",
+			...options,
+			headers: {
+				"Content-Type": null,
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Upload a file using base64 encoding
+	*
+	* Uploads a file to the server using base64-encoded content
+	*/
+	static uploadFileBase64(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/files/upload/base64",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a file
+	*
+	* Removes a file from the system by ID
+	*/
+	static deleteFile(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/files/{file_id}",
+			...options
+		});
+	}
+	/**
+	* Get a file by ID
+	*
+	* Returns the data and metadata of a specific file
+	*/
+	static getFile(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/files/{file_id}",
+			...options
+		});
+	}
+	/**
+	* Download a file
+	*
+	* Streams the file content to the client
+	*/
+	static downloadFile(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/files/{file_id}/download",
+			...options
+		});
+	}
+	/**
+	* Update file metadata
+	*
+	* Updates the metadata field of a file
+	*/
+	static updateFileMetadata(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/files/{file_id}/metadata",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Download file as base64
+	*
+	* Returns the file content encoded as base64
+	*/
+	static downloadFileBase64(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/files/{file_id}/download/base64",
+			...options
+		});
+	}
+	/**
+	* Get file tags
+	*
+	* Returns all tags attached to the file
+	*/
+	static getFileTags(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/files/{file_id}/tags",
+			...options
+		});
+	}
+	/**
+	* Merge file tags
+	*
+	* Merges provided tags with existing tags
+	*/
+	static mergeFileTags(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/files/{file_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Replace file tags
+	*
+	* Replaces all tags on the file with the provided tags
+	*/
+	static replaceFileTags(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/files/{file_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Formations = class {
+	/**
+	* Validate a formation template
+	*
+	* Validates a formation template without creating any resources. Returns a list of errors and warnings. Accepts the template as a JSON object or as a YAML/JSON string.
+	*
+	*/
+	static validateFormation(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/formations/validate",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Plan a formation deployment
+	*
+	* Computes a diff between the desired template and the current stack state without making any changes. Returns the list of planned actions.
+	*
+	*/
+	static planFormation(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/formations/plan",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List formations
+	*
+	* Returns all formation stacks for a project
+	*/
+	static listFormations(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/formations",
+			...options
+		});
+	}
+	/**
+	* Create a new formation
+	*
+	* Validates the template, creates the formation record, then provisions all declared resources in dependency order.
+	*
+	*/
+	static createFormation(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/formations",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete an formation
+	*
+	* Deletes the formation stack and all its managed resources in reverse dependency order.
+	*
+	*/
+	static deleteFormation(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/formations/{formation_id}",
+			...options
+		});
+	}
+	/**
+	* Get a specific formation
+	*
+	* Returns the formation stack including its current resources.
+	*/
+	static getFormation(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/formations/{formation_id}",
+			...options
+		});
+	}
+	/**
+	* Update an formation
+	*
+	* Applies a new template to the formation. Resources are created, updated, or deleted to reconcile the current state with the desired state.
+	*
+	*/
+	static updateFormation(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/formations/{formation_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List formation operation events
+	*
+	* Returns all operations (create, update, delete) with their event logs for the formation, ordered chronologically.
+	*
+	*/
+	static listFormationEvents(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/formations/{formation_id}/events",
+			...options
+		});
+	}
+};
+var Knowledge = class {
+	/**
+	* Search knowledge
+	*
+	* Searches across documents and memory entries using semantic search, file paths, document IDs, or memory IDs/tags. At least one of `query`, `document_paths`, `document_ids`, `memory_ids`, or `memory_tags` must be provided.
+	*/
+	static searchKnowledge(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/knowledge/search",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Memories = class {
+	/**
+	* List memories
+	*
+	* Returns a list of memory configurations for a project
+	*/
+	static listMemories(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/memories",
+			...options
+		});
+	}
+	/**
+	* Create a memory
+	*
+	* Creates a new memory configuration in a project
+	*/
+	static createMemory(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/memories",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a memory
+	*
+	* Deletes a memory configuration
+	*/
+	static deleteMemory(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/memories/{memory_id}",
+			...options
+		});
+	}
+	/**
+	* Get a memory
+	*
+	* Returns a single memory configuration by ID
+	*/
+	static getMemory(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/memories/{memory_id}",
+			...options
+		});
+	}
+	/**
+	* Update a memory
+	*
+	* Updates an existing memory configuration
+	*/
+	static updateMemory(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/memories/{memory_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var MemoryEntries = class {
+	/**
+	* List memory entries
+	*
+	* Returns all entries in a memory container
+	*/
+	static listMemoryEntries(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/memories/{memory_id}/entries",
+			...options
+		});
+	}
+	/**
+	* Create a memory entry
+	*
+	* Creates a new entry in the specified memory container. Automatically generates an embedding for semantic search.
+	*/
+	static createMemoryEntry(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/memories/{memory_id}/entries",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a memory entry
+	*
+	* Deletes a memory entry
+	*/
+	static deleteMemoryEntry(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/memories/{memory_id}/entries/{entry_id}",
+			...options
+		});
+	}
+	/**
+	* Get a memory entry
+	*
+	* Returns a single memory entry by ID
+	*/
+	static getMemoryEntry(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/memories/{memory_id}/entries/{entry_id}",
+			...options
+		});
+	}
+	/**
+	* Update a memory entry
+	*
+	* Updates an existing memory entry. Regenerates the embedding if content changes.
+	*/
+	static updateMemoryEntry(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/memories/{memory_id}/entries/{entry_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Orchestrations = class {
+	/**
+	* List orchestrations
+	*
+	* Returns orchestrations accessible to the caller.
+	*/
+	static listOrchestrations(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/orchestrations",
+			...options
+		});
+	}
+	/**
+	* Create an orchestration
+	*
+	* Creates a new orchestration workflow definition in the project.
+	*/
+	static createOrchestration(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/orchestrations",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete an orchestration
+	*
+	* Deletes an orchestration definition and all its runs.
+	*/
+	static deleteOrchestration(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/orchestrations/{orchestration_id}",
+			...options
+		});
+	}
+	/**
+	* Get an orchestration
+	*
+	* Returns the orchestration with nodes and edges.
+	*/
+	static getOrchestration(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/orchestrations/{orchestration_id}",
+			...options
+		});
+	}
+	/**
+	* Update an orchestration
+	*
+	* Partially updates an orchestration definition.
+	*/
+	static updateOrchestration(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/orchestrations/{orchestration_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List orchestration runs
+	*
+	* Returns all runs for an orchestration.
+	*/
+	static listOrchestrationRuns(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/orchestrations/{orchestration_id}/runs",
+			...options
+		});
+	}
+	/**
+	* Start an orchestration run
+	*
+	* Creates and immediately executes a new run for the orchestration.
+	*/
+	static startOrchestrationRun(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/orchestrations/{orchestration_id}/runs",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Cancel an orchestration run
+	*
+	* Cancels a running or paused orchestration run.
+	*/
+	static cancelOrchestrationRun(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/orchestrations/{orchestration_id}/runs/{run_id}/cancel",
+			...options
+		});
+	}
+	/**
+	* Submit human input
+	*
+	* Provides human input to a paused orchestration run waiting at a human node.
+	*/
+	static submitHumanInput(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/orchestrations/{orchestration_id}/runs/{run_id}/human-input",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Resume an orchestration run
+	*
+	* Resumes a paused orchestration run from its last checkpoint.
+	*/
+	static resumeOrchestrationRun(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/orchestrations/{orchestration_id}/runs/{run_id}/resume",
+			...options
+		});
+	}
+	/**
+	* Get an orchestration run
+	*
+	* Returns the status, state, and artifacts of a specific run.
+	*/
+	static getOrchestrationRun(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/orchestrations/{orchestration_id}/runs/{run_id}",
+			...options
+		});
+	}
+};
+var Policies = class {
+	/**
+	* List all policies
+	*
+	* Returns a list of all global policies. Requires admin role.
+	*/
+	static listPolicies(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/policies",
+			...options
+		});
+	}
+	/**
+	* Create a policy
+	*
+	* Creates a new global policy. Requires admin role.
+	*/
+	static createPolicy(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/policies",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a policy
+	*
+	* Deletes a global policy. Requires admin role.
+	*/
+	static deletePolicy(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/policies/{policy_id}",
+			...options
+		});
+	}
+	/**
+	* Get a policy
+	*
+	* Returns details of a specific policy. Requires admin role.
+	*/
+	static getPolicy(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/policies/{policy_id}",
+			...options
+		});
+	}
+	/**
+	* Update a policy
+	*
+	* Updates an existing global policy. Requires admin role.
+	*/
+	static updatePolicy(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/policies/{policy_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Projects = class {
+	/**
+	* Create a project
+	*
+	* Creates a new project. Requires admin role.
+	*/
+	static createProject(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/projects",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a project
+	*
+	* Deletes a project. Requires admin role.
+	*/
+	static deleteProject(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/projects/{project_id}",
+			...options
+		});
+	}
+	/**
+	* Get a project
+	*
+	* Returns details of a specific project.
+	*/
+	static getProject(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/projects/{project_id}",
+			...options
+		});
+	}
+};
+var Secrets = class {
+	/**
+	* List secrets
+	*
+	* Returns a list of secrets for a project
+	*/
+	static listSecrets(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/secrets",
+			...options
+		});
+	}
+	/**
+	* Create a secret
+	*
+	* Creates a new encrypted secret in a project
+	*/
+	static createSecret(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/secrets",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a secret
+	*
+	* Deletes a secret
+	*/
+	static deleteSecret(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/secrets/{secret_id}",
+			...options
+		});
+	}
+	/**
+	* Get a secret
+	*
+	* Returns a specific secret
+	*/
+	static getSecret(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/secrets/{secret_id}",
+			...options
+		});
+	}
+	/**
+	* Update a secret
+	*
+	* Updates a secret's name and/or value
+	*/
+	static updateSecret(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/secrets/{secret_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Sessions = class {
+	/**
+	* List sessions
+	*
+	* Returns sessions for the specified agent, optionally filtered by actorId and status.
+	*/
+	static listAgentSessions(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/agents/{agent_id}/sessions",
+			...options
+		});
+	}
+	/**
+	* Create a session
+	*
+	* Creates a new session for the specified agent. Internally creates a conversation and two actors (agent + user) so the caller only needs this single call to start interacting with the agent.
+	*
+	*/
+	static createAgentSession(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/agents/{agent_id}/sessions",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a session
+	*
+	* Deletes the session and its underlying conversation and actors.
+	*/
+	static deleteAgentSession(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/agents/{agent_id}/sessions/{session_id}",
+			...options
+		});
+	}
+	/**
+	* Get a session
+	*
+	* Returns details of a single session.
+	*/
+	static getAgentSession(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/agents/{agent_id}/sessions/{session_id}",
+			...options
+		});
+	}
+	/**
+	* Update a session
+	*
+	* Updates the session name and/or status.
+	*/
+	static updateSession(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/agents/{agent_id}/sessions/{session_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List session messages
+	*
+	* Returns messages in the session with simplified roles (user/assistant) instead of raw actor IDs.
+	*
+	*/
+	static listAgentSessionMessages(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/agents/{agent_id}/sessions/{session_id}/messages",
+			...options
+		});
+	}
+	/**
+	* Add a user message
+	*
+	* Saves a user message to the session. When autoGenerate is enabled on the session and no generation is currently in progress, generation is triggered automatically and the response mirrors GenerateSessionResponse. Otherwise returns the saved user message.
+	*
+	*/
+	static addSessionMessage(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/agents/{agent_id}/sessions/{session_id}/messages",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Trigger agent generation
+	*
+	* Triggers the agent to generate a response based on the current conversation. Returns the assistant reply or a requires_action status if the agent needs client tool outputs. Pass ?async=true for a 202 accepted response when you do not need to wait for the result.
+	*
+	*/
+	static generateSessionResponse(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/agents/{agent_id}/sessions/{session_id}/generate",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Submit tool outputs
+	*
+	* Submits client tool outputs for a generation that returned requires_action. The agent continues its loop and returns the final or next requires_action result.
+	*
+	*/
+	static submitSessionToolOutputs(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/agents/{agent_id}/sessions/{session_id}/tool-outputs",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get session tags
+	*
+	* Returns the session's tags object.
+	*/
+	static getSessionTags(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/agents/{agent_id}/sessions/{session_id}/tags",
+			...options
+		});
+	}
+	/**
+	* Merge session tags
+	*
+	* Merges the provided tags into the session's existing tags.
+	*/
+	static mergeSessionTags(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/agents/{agent_id}/sessions/{session_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Replace session tags
+	*
+	* Replaces all tags on the session.
+	*/
+	static replaceSessionTags(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/agents/{agent_id}/sessions/{session_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Tools = class {
+	/**
+	* List tools
+	*
+	* Returns all tools in the project.
+	*/
+	static listTools(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/tools",
+			...options
+		});
+	}
+	/**
+	* Create a tool
+	*
+	* Creates a new tool in the project.
+	*/
+	static createTool(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/tools",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a tool
+	*
+	* Deletes a tool by ID.
+	*/
+	static deleteTool(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/tools/{tool_id}",
+			...options
+		});
+	}
+	/**
+	* Get a tool
+	*
+	* Returns a single tool by ID.
+	*/
+	static getTool(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/tools/{tool_id}",
+			...options
+		});
+	}
+	/**
+	* Update a tool
+	*
+	* Updates an existing tool.
+	*/
+	static updateTool(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/tools/{tool_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Call a tool
+	*
+	* Directly invokes a tool and returns its output. Supported for `http`, `soat`, and `mcp` tools. `client` tools cannot be invoked server-side and will return 422.
+	* For `soat` and `mcp` tools the `action` field is required and identifies which action (SOAT) or tool name (MCP) to invoke. For `http` tools `action` is ignored.
+	* `preset_parameters` stored on the tool are merged with the caller-supplied `input` before execution; preset keys take lower precedence.
+	*
+	*/
+	static callTool(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/tools/{tool_id}/call",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Traces = class {
+	/**
+	* List traces
+	*
+	* Returns a paginated list of execution traces for the project.
+	*/
+	static listTraces(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/traces",
+			...options
+		});
+	}
+	/**
+	* Get a trace
+	*
+	* Returns a single trace by ID.
+	*/
+	static getTrace(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/traces/{trace_id}",
+			...options
+		});
+	}
+	/**
+	* Get trace tree
+	*
+	* Returns the full execution tree rooted at the given trace (or its root if the given trace is a child). Each node represents one agent's execution session. The `children` array contains traces triggered by sub-agent tool calls from that trace.
+	*
+	*/
+	static getTraceTree(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/traces/{trace_id}/tree",
+			...options
+		});
+	}
+	/**
+	* Get generation IDs for a trace
+	*
+	* Returns all generation IDs associated with the trace.
+	*/
+	static getTraceGenerations(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/traces/{trace_id}/generations",
+			...options
+		});
+	}
+};
+var Users = class {
+	/**
+	* List all users
+	*
+	* Returns a list of all users
+	*/
+	static listUsers(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/users",
+			...options
+		});
+	}
+	/**
+	* Create a user
+	*
+	* Creates a new user in the system
+	*/
+	static createUser(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/users",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a user by ID
+	*
+	* Deletes a specific user
+	*/
+	static deleteUser(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/users/{user_id}",
+			...options
+		});
+	}
+	/**
+	* Get a user by ID
+	*
+	* Returns the data of a specific user
+	*/
+	static getUser(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/users/{user_id}",
+			...options
+		});
+	}
+	/**
+	* Create the first admin user
+	*
+	* Creates the first admin user. Returns 409 if any user already exists.
+	*/
+	static bootstrapUser(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/users/bootstrap",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Login user
+	*
+	* Authenticates a user and returns a JWT token
+	*/
+	static loginUser(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/users/login",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get policies attached to a user
+	*
+	* Returns the list of policies attached to a user. Requires admin role.
+	*/
+	static getUserPolicies(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/users/{user_id}/policies",
+			...options
+		});
+	}
+	/**
+	* Attach policies to a user
+	*
+	* Replaces the user's policy list with the provided policy IDs. Requires admin role.
+	*/
+	static attachUserPolicies(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/users/{user_id}/policies",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Webhooks = class {
+	/**
+	* List webhooks for a project
+	*
+	* Lists all webhooks configured for the specified project
+	*/
+	static listWebhooks(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/projects/{project_id}/webhooks",
+			...options
+		});
+	}
+	/**
+	* Create a webhook
+	*
+	* Creates a new webhook for the specified project
+	*/
+	static createWebhook(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/projects/{project_id}/webhooks",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a webhook
+	*
+	* Deletes a webhook and stops all event deliveries
+	*/
+	static deleteWebhook(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/projects/{project_id}/webhooks/{webhook_id}",
+			...options
+		});
+	}
+	/**
+	* Get a webhook
+	*
+	* Retrieves the details of a specific webhook
+	*/
+	static getWebhook(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/projects/{project_id}/webhooks/{webhook_id}",
+			...options
+		});
+	}
+	/**
+	* Update a webhook
+	*
+	* Updates an existing webhook's configuration
+	*/
+	static updateWebhook(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/projects/{project_id}/webhooks/{webhook_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List deliveries for a webhook
+	*
+	* Lists all event deliveries for a specific webhook
+	*/
+	static listWebhookDeliveries(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/projects/{project_id}/webhooks/{webhook_id}/deliveries",
+			...options
+		});
+	}
+	/**
+	* Get a delivery
+	*
+	* Retrieves the details of a specific webhook delivery
+	*/
+	static getWebhookDelivery(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/projects/{project_id}/webhooks/{webhook_id}/deliveries/{delivery_id}",
+			...options
+		});
+	}
+	/**
+	* Get webhook secret
+	*
+	* Retrieves the signing secret for the specified webhook
+	*/
+	static getWebhookSecret(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/projects/{project_id}/webhooks/{webhook_id}/secret",
+			...options
+		});
+	}
+	/**
+	* Rotate webhook secret
+	*
+	* Rotates the secret key for the specified webhook
+	*/
+	static rotateWebhookSecret(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/projects/{project_id}/webhooks/{webhook_id}/rotate-secret",
+			...options
+		});
+	}
+};
+//#endregion
+//#region src/soatClient.ts
+/**
+* Wraps a static SDK class so that all its methods are callable as instance
+* methods, with the given `client` automatically injected into every call.
+*
+* The return type is preserved as `T` (= `typeof <StaticClass>`), so callers
+* get full TypeScript auto-complete and type checking without having to pass
+* `client` themselves.
+*/
+const bindResource = (SdkClass, client) => {
+	return new Proxy(SdkClass, { get: (target, prop) => {
+		const value = target[prop];
+		if (typeof value === "function") return (options) => {
+			return value({
+				...options,
+				client
+			});
+		};
+		return value;
+	} });
+};
+/**
+* Stripe-style SOAT client.
+*
+* Create an instance once and reuse it throughout your application:
+*
+* ```ts
+* import { SoatClient } from '@soat/sdk';
+*
+* const soat = new SoatClient({ baseUrl: 'https://api.example.com', token: 'sk_...' });
+*
+* const { data, error } = await soat.sessions.addSessionMessage({
+*   path: { agent_id: AGENT_ID, session_id: SESSION_ID },
+*   body: { message: 'What is the capital of France?' },
+* });
+* ```
+*
+* The instance exposes one property per API resource. Each property mirrors
+* the corresponding static class from the generated SDK, so all method
+* signatures, types, and return values are identical — the only difference
+* is that you never need to supply `client` yourself.
+*/
+var SoatClient = class {
+	actors;
+	agents;
+	aiProviders;
+	apiKeys;
+	chats;
+	conversations;
+	documents;
+	files;
+	formations;
+	knowledge;
+	memories;
+	memoryEntries;
+	policies;
+	projects;
+	secrets;
+	sessions;
+	tools;
+	traces;
+	users;
+	webhooks;
+	constructor({ baseUrl, token, headers } = {}) {
+		const authHeaders = token ? { Authorization: `Bearer ${token}` } : {};
+		const httpClient = createClient(createConfig({
+			baseUrl: baseUrl ?? "",
+			headers: {
+				...authHeaders,
+				...headers
+			}
+		}));
+		this.actors = bindResource(Actors, httpClient);
+		this.agents = bindResource(Agents, httpClient);
+		this.aiProviders = bindResource(AiProviders, httpClient);
+		this.apiKeys = bindResource(ApiKeys, httpClient);
+		this.chats = bindResource(Chats, httpClient);
+		this.conversations = bindResource(Conversations, httpClient);
+		this.documents = bindResource(Documents, httpClient);
+		this.files = bindResource(Files, httpClient);
+		this.formations = bindResource(Formations, httpClient);
+		this.knowledge = bindResource(Knowledge, httpClient);
+		this.memories = bindResource(Memories, httpClient);
+		this.memoryEntries = bindResource(MemoryEntries, httpClient);
+		this.policies = bindResource(Policies, httpClient);
+		this.projects = bindResource(Projects, httpClient);
+		this.secrets = bindResource(Secrets, httpClient);
+		this.sessions = bindResource(Sessions, httpClient);
+		this.tools = bindResource(Tools, httpClient);
+		this.traces = bindResource(Traces, httpClient);
+		this.users = bindResource(Users, httpClient);
+		this.webhooks = bindResource(Webhooks, httpClient);
+	}
+};
+//#endregion
+exports.Actors = Actors;
+exports.Agents = Agents;
+exports.AiProviders = AiProviders;
+exports.ApiKeys = ApiKeys;
+exports.Chats = Chats;
+exports.Conversations = Conversations;
+exports.Documents = Documents;
+exports.Files = Files;
+exports.Formations = Formations;
+exports.Knowledge = Knowledge;
+exports.Memories = Memories;
+exports.MemoryEntries = MemoryEntries;
+exports.Orchestrations = Orchestrations;
+exports.Policies = Policies;
+exports.Projects = Projects;
+exports.Secrets = Secrets;
+exports.Sessions = Sessions;
+exports.SoatClient = SoatClient;
+exports.Tools = Tools;
+exports.Traces = Traces;
+exports.Users = Users;
+exports.Webhooks = Webhooks;
+exports.createClient = createClient;
+exports.createConfig = createConfig;