@naturali/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1780 @@
+//#region src/generated/core/bodySerializer.gen.ts
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+//#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;
+				const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+				await sleep(backoff);
+			}
+		}
+	};
+	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 Agents = class {
+	/**
+	* List agents
+	*
+	* Lists the agents in the project.
+	*/
+	static listAgents(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/agents",
+			...options
+		});
+	}
+	/**
+	* Create an agent
+	*
+	* Create an agent bound to one of the project's providers (provider_id), optionally attaching tools (tool_ids). See AgentCreate for the runtime config fields.
+	*
+	*/
+	static createAgent(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/agents",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete an agent
+	*
+	* Deletes the backing SOAT agent. Returns 409 if the agent still has dependent generations or traces — pass `force=true` to delete those along with the agent (destructive and irreversible).
+	*
+	*/
+	static deleteAgent(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/agents/{agent_id}",
+			...options
+		});
+	}
+	/**
+	* Get an agent
+	*/
+	static getAgent(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/agents/{agent_id}",
+			...options
+		});
+	}
+	/**
+	* Update an agent
+	*
+	* Change the bound provider, name, model, instructions, sampling/step config, attached tools (tool_ids/tool_choice), or the naturali-side status. At least one field is required.
+	*
+	*/
+	static updateAgent(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/agents/{agent_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var ApiKeys = class {
+	/**
+	* List API keys
+	*
+	* Lists API keys accessible to the caller. A project-scoped credential sees only keys in its project; an account-scoped credential sees all keys in the account. Raw secrets are never returned.
+	*
+	*/
+	static listApiKeys(options) {
+		return (options?.client ?? client).get({
+			url: "/v1/api-keys",
+			...options
+		});
+	}
+	/**
+	* Create an API key
+	*
+	* Creates an API key. When `project_id` is set the key is scoped to that project (the default and recommended stance); omit it for an account-scoped key. `capabilities` narrows what the key may do; when omitted the key inherits the creator's capabilities. The raw `key` (nat_sk_…) is returned only in this response.
+	*
+	*/
+	static createApiKey(options) {
+		return (options.client ?? client).post({
+			url: "/v1/api-keys",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Revoke an API key
+	*
+	* Revokes an API key immediately. Subsequent use returns 401.
+	*/
+	static deleteApiKey(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/api-keys/{api_key_id}",
+			...options
+		});
+	}
+	/**
+	* Get an API key
+	*
+	* Returns metadata for an API key. The raw secret is never returned after creation.
+	*/
+	static getApiKey(options) {
+		return (options.client ?? client).get({
+			url: "/v1/api-keys/{api_key_id}",
+			...options
+		});
+	}
+	/**
+	* Update an API key
+	*
+	* Rename an API key or replace its capability set. The scope (project vs account) is immutable.
+	*/
+	static updateApiKey(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/api-keys/{api_key_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Rotate an API key
+	*
+	* Issues a new secret for the same key record (same id, scope and capabilities) and invalidates the previous secret. The new raw `key` is returned only in this response.
+	*
+	*/
+	static rotateApiKey(options) {
+		return (options.client ?? client).post({
+			url: "/v1/api-keys/{api_key_id}:rotate",
+			...options
+		});
+	}
+};
+var Auth = class {
+	/**
+	* Create an account
+	*
+	* Creates a user and opens a session. A verification email is sent separately; unverified accounts may be limited until verified.
+	*
+	*/
+	static signup(options) {
+		return (options.client ?? client).post({
+			url: "/v1/auth/signup",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Log in
+	*
+	* Exchanges email + password for an access JWT and a refresh token.
+	*/
+	static login(options) {
+		return (options.client ?? client).post({
+			url: "/v1/auth/login",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Refresh a session
+	*
+	* Exchanges a valid refresh token for a new access JWT and a rotated refresh token. Refresh tokens are single-use; presenting a previously-rotated token is treated as reuse and revokes the whole session family (createRefreshRotation reuse detection).
+	*
+	*/
+	static refreshSession(options) {
+		return (options.client ?? client).post({
+			url: "/v1/auth/refresh",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Log out
+	*
+	* Revokes the current refresh token (and its rotation family). Pass `all: true` to revoke every active session for the user.
+	*
+	*/
+	static logout(options) {
+		return (options?.client ?? client).post({
+			url: "/v1/auth/logout",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	/**
+	* Request a password reset
+	*
+	* Sends a password-reset email if the address has an account. Always responds 202 so account existence is never leaked.
+	*
+	*/
+	static requestPasswordReset(options) {
+		return (options.client ?? client).post({
+			url: "/v1/auth/password/reset-request",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Complete a password reset
+	*
+	* Sets a new password using a valid one-time reset token, then revokes existing sessions.
+	*/
+	static confirmPasswordReset(options) {
+		return (options.client ?? client).post({
+			url: "/v1/auth/password/reset",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Verify an email address
+	*
+	* Confirms an email address using a one-time verification token.
+	*/
+	static verifyEmail(options) {
+		return (options.client ?? client).post({
+			url: "/v1/auth/verify-email",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get the current identity
+	*
+	* Returns the user behind the presented access token.
+	*/
+	static getCurrentUser(options) {
+		return (options?.client ?? client).get({
+			url: "/v1/auth/me",
+			...options
+		});
+	}
+};
+var Channels = class {
+	/**
+	* List channels
+	*
+	* Lists the channels connected in the project.
+	*/
+	static listChannels(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/channels",
+			...options
+		});
+	}
+	/**
+	* Connect a channel
+	*
+	* Connect a channel. The required fields depend on `channel`; no credential is ever returned.
+	* **Discord** (`channel: discord`) — supply `application_id` and `bot_token`, plus the `modes` selecting which Gateway flows to serve (direct messages, and/or @mention-opens-a-thread). Returns `501` when the deployment has no `CHANNEL_TOKEN_KEY` configured.
+	* **WhatsApp** (default) — one of two credential paths, both filling the same write-only secret:
+	* * **BYOT** (`credential_source: byot`, default) — supply
+	* `phone_number_id` and `access_token` from your own Meta app.
+	*
+	* * **Embedded signup** (`credential_source: embedded_signup`) — supply
+	* `code` and `waba_id` (and optionally `pin`) from the Meta popup;
+	* naturali exchanges the `code` for the token and subscribes its app to
+	* the WABA, so the customer never hands over a token. Returns `501` on
+	* deployments where Meta App credentials are not configured.
+	*
+	*/
+	static createChannel(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/channels",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a channel
+	*
+	* Deletes the channel and whatever it provisioned — the WhatsApp send tool and write-only credential secret, or the Discord channel's sealed bot token (dropped with the row, closing its gateway connection).
+	*
+	*/
+	static deleteChannel(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/channels/{channel_id}",
+			...options
+		});
+	}
+	/**
+	* Get a channel
+	*/
+	static getChannel(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/channels/{channel_id}",
+			...options
+		});
+	}
+	/**
+	* Update a channel
+	*
+	* Rotate the credential, update the kind's config (`waba_id` / `credential_source` for WhatsApp, `modes` for Discord), or flip the naturali-side status. At least one field is required. Rotating a WhatsApp token stores a new write-only secret, repoints the send tool and deletes the old secret; rotating a Discord bot token reseals it and the gateway worker reconnects with it.
+	*
+	*/
+	static updateChannel(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/channels/{channel_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Unbind the channel
+	*/
+	static deleteChannelBinding(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/channels/{channel_id}/binding",
+			...options
+		});
+	}
+	/**
+	* Get the channel's binding
+	*/
+	static getChannelBinding(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/channels/{channel_id}/binding",
+			...options
+		});
+	}
+	/**
+	* Set the channel's binding
+	*
+	* Create or replace the channel's agent binding (a channel has one binding in v1). `agent_id` is required and must be an agent owned in the project; `language` / `config` / `status` default to null / null / active when absent (full replace).
+	*
+	*/
+	static setChannelBinding(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/channels/{channel_id}/binding",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List the channel's conversations
+	*
+	* A cursor page of the channel's conversations, newest first. A conversation is one contact's dialogue on the channel — the continuity anchor that resumes the same SOAT session instead of starting fresh per message — so this is the read path for who has talked to the channel and which actor/session their dialogue resolved to.
+	* Conversations are created by the inbound path (the WhatsApp webhook, the Discord gateway worker) when a real message arrives; there is no way to create one directly.
+	*
+	*/
+	static listChannelConversations(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/channels/{channel_id}/conversations",
+			...options
+		});
+	}
+	/**
+	* Get a conversation
+	*/
+	static getChannelConversation(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/channels/{channel_id}/conversations/{conversation_id}",
+			...options
+		});
+	}
+	/**
+	* Read a conversation's transcript
+	*
+	* The conversation's messages, oldest first. naturali stores no message bodies — the dialogue lives in the SOAT session the conversation maps to, so this reads through to SOAT. Pagination is `limit`/`offset` rather than an opaque cursor because the upstream is offset-based over a stable `position` ordering.
+	*
+	*/
+	static listChannelConversationMessages(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/channels/{channel_id}/conversations/{conversation_id}/messages",
+			...options
+		});
+	}
+};
+var Contacts = class {
+	/**
+	* List contacts
+	*
+	* A cursor page of the project's contacts, newest first.
+	* `channel` + `identifier` (supplied together) is the identity lookup — "who is this phone number?" — and returns at most one contact, following the merge pointer to whoever holds the identifier today. `external_id` asks the same question from the customer's side of the mapping. Contacts merged away are omitted unless `include_merged` asks for them.
+	*
+	*/
+	static listContacts(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/contacts",
+			...options
+		});
+	}
+	/**
+	* Create a contact
+	*
+	* Record a contact the customer already knows about, optionally with the identifiers it is expected to arrive at.
+	* Optional by design — the inbound path creates contacts on its own. This is for the embedder who has a user in their own system and wants naturali to agree about who that is before the first message, which is what makes `external_id` (and, through it, a session's `tool_context`) useful. No SOAT actor is created here; the contact gets one on first need.
+	*
+	*/
+	static createContact(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/contacts",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Erase a contact
+	*
+	* **Erasure (C4/LGPD).** Not a soft delete and not reversible: the contact's sessions — with their messages and media — its SOAT actor, its memory container and every identifier it was reachable at are removed, along with the merge records that reference it.
+	* The upstream deletes happen first, so a failure there aborts before the local pointers are dropped and a retry can still find what is left. A contact that was merged into another cannot be erased directly: its data lives with the survivor, so erase that one.
+	*
+	*/
+	static deleteContact(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/contacts/{contact_id}",
+			...options
+		});
+	}
+	/**
+	* Get a contact
+	*/
+	static getContact(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/contacts/{contact_id}",
+			...options
+		});
+	}
+	/**
+	* Update a contact
+	*
+	* Retune the customer-owned fields. At least one is required. Identities are attached and detached through their own sub-resource, because each one is a claim about reachability rather than a property of the record.
+	*
+	*/
+	static updateContact(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/contacts/{contact_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Attach an identity
+	*
+	* Attach a `(channel, identifier)` pair — the manual half of what the inbound path does automatically, and the way a customer tells naturali that a number it has never seen belongs to a user it already knows. The identifier must be free (C3).
+	*
+	*/
+	static createContactIdentity(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/contacts/{contact_id}/identities",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Detach an identity
+	*
+	* Detach an identifier attached in error. Refused with `identity_in_use` once a dialogue hangs off it: dropping an identifier with history is erasure wearing a smaller name, and erasure has its own route that actually removes the messages instead of orphaning them.
+	*
+	*/
+	static deleteContactIdentity(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/contacts/{contact_id}/identities/{identity_id}",
+			...options
+		});
+	}
+	/**
+	* List the contact's conversations
+	*
+	* Every dialogue the contact has, across channels, newest first. The channel-scoped list answers "who has talked to this number?"; this one answers "where has this human talked to us?" — the read that makes a merge visible, since both channels' rows then appear under one contact.
+	*
+	*/
+	static listContactConversations(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/contacts/{contact_id}/conversations",
+			...options
+		});
+	}
+	/**
+	* Merge another contact into this one
+	*
+	* Fold `source_contact_id` into this contact — "same human, two identifiers" (C4).
+	* What moves: every identity and every conversation, so the survivor's history is the union of both. What is *shared* rather than moved: agent memory — SOAT hangs it off the actor, so the source's actor is re-pointed at the survivor's memory container and both keep answering with one recollection. Existing sessions keep working, which is the point of not rewriting them.
+	* The source is not deleted: it stays as a tombstone pointing at the survivor, and the returned merge record lists exactly what moved, so the merge can be audited and reverted.
+	*
+	*/
+	static mergeContact(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/contacts/{contact_id}:merge",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List the contact's merges
+	*
+	* The contact's merge history, newest first, from both sides: the merges it absorbed and the one that absorbed it. The audit half of C4.
+	*
+	*/
+	static listContactMerges(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/contacts/{contact_id}/merges",
+			...options
+		});
+	}
+	/**
+	* Revert a merge
+	*
+	* Undo a merge (C4). Replays the record backwards: the identities and conversations it lists go back to the source, the source's actor is re-pointed at the memory it had before, and the tombstone becomes a contact again. Anything that arrived *after* the merge stays with the survivor — it was never the source's.
+	* Only the merge still in force can be reverted; a source that has since been merged somewhere else has to be unwound from the top (`merge_superseded`).
+	*
+	*/
+	static revertContactMerge(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/contacts/{contact_id}/merges/{merge_id}:revert",
+			...options
+		});
+	}
+};
+var Generations = class {
+	/**
+	* List an agent's generations
+	*
+	* Lists the generation records the agent has produced, newest first. Filter by lifecycle `status` to find the failures without paging everything the agent has ever run.
+	*
+	*/
+	static listAgentGenerations(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/generations",
+			...options
+		});
+	}
+	/**
+	* Run an agent generation
+	*
+	* Sends messages to the agent, resolves its tools, and runs the model loop. Returns the final text when `status` is `completed` (plus `object` when the agent has an output schema), or the pending `tool_calls` when `status` is `requires_action`. With `stream: true` the response is a Server-Sent Events stream (Content-Type text/event-stream) proxied from SOAT instead of a single JSON body.
+	*
+	*/
+	static createGeneration(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/generations",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get a generation
+	*
+	* Returns one generation record. Flat rather than nested under the agent, because the ids that need resolving arrive on their own — a session reply carries a `generation_id` with no agent in hand.
+	* A generation belonging to another project responds `404`, not `403` — the API never confirms that an id exists elsewhere.
+	*
+	*/
+	static getGeneration(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/generations/{generation_id}",
+			...options
+		});
+	}
+};
+var Knowledge = class {
+	/**
+	* List collections
+	*
+	* Lists the knowledge collections in the project.
+	*/
+	static listKnowledgeCollections(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/knowledge/collections",
+			...options
+		});
+	}
+	/**
+	* Create a collection
+	*
+	* Create a knowledge collection. The name is the key manifests reference (an agent's `knowledge:` block) and must be unique within the project.
+	*
+	*/
+	static createKnowledgeCollection(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/knowledge/collections",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a collection
+	*
+	* Deletes an empty collection. Returns 409 if the collection still has documents (delete them first).
+	*
+	*/
+	static deleteKnowledgeCollection(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}",
+			...options
+		});
+	}
+	/**
+	* Get a collection
+	*/
+	static getKnowledgeCollection(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}",
+			...options
+		});
+	}
+	/**
+	* Update a collection
+	*
+	* Rename the collection or edit its description. At least one field is required.
+	*/
+	static updateKnowledgeCollection(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Query a collection (retrieval preview)
+	*
+	* Retrieval preview (API.md §4, K5): returns the chunks the collection would surface for a question — debuggable standalone, before any agent is bound to it. This is the `…:query` action; the path segment is `{collection_id}:query`.
+	*
+	*/
+	static queryKnowledgeCollection(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List documents
+	*
+	* Lists the documents in the collection, with their ingestion status.
+	*/
+	static listKnowledgeDocuments(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents",
+			...options
+		});
+	}
+	/**
+	* Create a document
+	*
+	* Add an inline-text document to the collection. The platform ingests the content (chunk + embed) and records the document's ingestion status. File upload (PDF/binary) is a deliberate follow-up.
+	*
+	*/
+	static createKnowledgeDocument(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a document
+	*/
+	static deleteKnowledgeDocument(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents/{document_id}",
+			...options
+		});
+	}
+	/**
+	* Get a document
+	*
+	* Returns the document, including its text content when ingestion is complete.
+	*/
+	static getKnowledgeDocument(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents/{document_id}",
+			...options
+		});
+	}
+	/**
+	* Re-ingest a document
+	*
+	* Re-run ingestion for a document against its stored source, resetting it to `pending` before re-processing — the recovery path for a `failed` ingest (API.md §4, K1). This is the `…:reingest` action; the path segment is `{document_id}:reingest`.
+	*
+	*/
+	static reingestKnowledgeDocument(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents/{document_id}",
+			...options
+		});
+	}
+};
+var Models = class {
+	/**
+	* List models
+	*
+	* Lists catalog models, newest sources merged and sorted by id. Filter by vendor, provider, output/input modality or status.
+	*
+	*/
+	static listModels(options) {
+		return (options?.client ?? client).get({
+			url: "/v1/models",
+			...options
+		});
+	}
+	/**
+	* Get a model
+	*/
+	static getModel(options) {
+		return (options.client ?? client).get({
+			url: "/v1/models/{model_id}",
+			...options
+		});
+	}
+};
+var Projects = class {
+	/**
+	* List projects
+	*
+	* Lists projects accessible to the caller.
+	*/
+	static listProjects(options) {
+		return (options?.client ?? client).get({
+			url: "/v1/projects",
+			...options
+		});
+	}
+	/**
+	* Create a project
+	*
+	* Creates a project (one per client or per environment).
+	*/
+	static createProject(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a project
+	*
+	* Permanently deletes the project and its backing SOAT project. Fails with 409 if the SOAT project still has dependent resources — remove them first, or pass `force=true` to delete the project and all its dependents (agents, providers, tools, sessions, generations, traces). Forcing is destructive and irreversible.
+	*
+	*/
+	static deleteProject(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}",
+			...options
+		});
+	}
+	/**
+	* Get a project
+	*/
+	static getProject(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}",
+			...options
+		});
+	}
+	/**
+	* Update a project
+	*
+	* Rename or archive a project. Archiving is reversible; resources are retained.
+	*/
+	static updateProject(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get per-project usage
+	*
+	* The per-project meter — the re-billing view (A11/C12/P3). Aggregates the project's usage over an optional [from, to] window, bucketed by a single dimension. Costs are the billing-grade cost_usd SOAT freezes at write time; null means nothing in the bucket was priced (never that it was free). Only managed providers are priced (on SOAT), so cost reflects managed usage; BYOK usage carries no LLM cost.
+	*
+	*/
+	static getProjectUsage(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/usage",
+			...options
+		});
+	}
+};
+var Providers = class {
+	/**
+	* List providers
+	*
+	* Lists the AI providers registered in the project.
+	*/
+	static listProviders(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/providers",
+			...options
+		});
+	}
+	/**
+	* Register a provider (managed or BYOK)
+	*
+	* Register a managed provider (naturali-keyed, priced on SOAT) or a BYOK provider (your credentials, stored write-only and never priced). See ProviderCreate for the fields each mode takes.
+	*
+	*/
+	static createProvider(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/providers",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a provider
+	*
+	* Deletes the backing SOAT ai_provider and its secret. Returns 409 if the provider is still referenced by live resources (agents) — detach those first. `force=true` clears only soft dependents (price overrides, usage history); live references always block deletion.
+	*
+	*/
+	static deleteProvider(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/providers/{provider_id}",
+			...options
+		});
+	}
+	/**
+	* Get a provider
+	*/
+	static getProvider(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/providers/{provider_id}",
+			...options
+		});
+	}
+	/**
+	* Update a provider
+	*
+	* Change the model, name or base URL, rotate the credentials (api_key), or set the naturali-side status. At least one field is required.
+	*
+	*/
+	static updateProvider(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/providers/{provider_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Sessions = class {
+	/**
+	* Open a session
+	*
+	* Opens a durable session against the agent. The session accumulates messages and is resumable by id; its lifecycle (open / closed / expired) and configuration live in the backing SOAT session.
+	*
+	*/
+	static createSession(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/sessions",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get a session
+	*
+	* Returns the session's current state — status, activity timestamps and configuration — read live from the backing SOAT session, so a resumed session reflects everything that has happened since it was opened.
+	*
+	*/
+	static getSession(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/sessions/{session_id}",
+			...options
+		});
+	}
+	/**
+	* Add a message
+	*
+	* Appends a user message to the session — plain `message` text or a `document_id`, exactly one of the two. `idempotency_key` makes the append safe to retry: a repeat with the same key returns the original message (HTTP 200) and triggers no new work. When the session has `auto_generate` on, the response is the agent's reply (a Generation shape) instead of the saved message.
+	*
+	*/
+	static addSessionMessage(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/sessions/{session_id}/messages",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Generate a response
+	*
+	* Runs the agent over the session's accumulated messages and returns its reply. `status` is `completed` with the assistant `message`, or `requires_action` with the pending `required_action` tool calls. `model` overrides the agent's default model for this turn only.
+	*
+	*/
+	static generateSessionResponse(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/sessions/{session_id}/generate",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Tools = class {
+	/**
+	* List tools
+	*
+	* Lists the tools registered in the project.
+	*/
+	static listTools(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/tools",
+			...options
+		});
+	}
+	/**
+	* Create a tool
+	*
+	* Create an http or mcp tool in the project. See ToolCreate for the fields each type takes. Any auth headers are stored write-only and never returned.
+	*
+	*/
+	static createTool(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/tools",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a tool
+	*
+	* Deletes the backing SOAT tool. Returns 409 if the tool is still attached to an agent (detach it first).
+	*
+	*/
+	static deleteTool(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/tools/{tool_id}",
+			...options
+		});
+	}
+	/**
+	* Get a tool
+	*/
+	static getTool(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/tools/{tool_id}",
+			...options
+		});
+	}
+	/**
+	* Update a tool
+	*
+	* Change the name, description, parameters, type-specific config (incl. rotating auth headers), or the naturali-side status. The tool `type` is immutable. At least one field is required.
+	*
+	*/
+	static updateTool(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/tools/{tool_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Traces = class {
+	/**
+	* List traces
+	*
+	* Lists the project's execution traces, newest first.
+	*/
+	static listTraces(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/traces",
+			...options
+		});
+	}
+	/**
+	* Get a trace
+	*
+	* Returns one trace. A trace belonging to another project responds `404`, not `403` — the API never confirms that an id exists elsewhere.
+	*
+	*/
+	static getTrace(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/traces/{trace_id}",
+			...options
+		});
+	}
+	/**
+	* Get a trace tree
+	*
+	* Returns the whole execution tree. Each node is one agent's execution; `children` are the traces its sub-agent tool calls started.
+	* Asking for a child returns the tree from its root, so the response is the full execution either way — pass `include=generations` and one call is enough to render a finished run.
+	*
+	*/
+	static getTraceTree(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/traces/{trace_id}/tree",
+			...options
+		});
+	}
+	/**
+	* List a trace's generations
+	*
+	* Lists the generations recorded under this trace — the model loops the execution ran, including sub-agent generations linked by `initiator_generation_id`.
+	*
+	*/
+	static listTraceGenerations(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/traces/{trace_id}/generations",
+			...options
+		});
+	}
+};
+//#endregion
+//#region src/naturaliClient.ts
+/**
+* Wraps a generated static SDK class so every method is callable without
+* passing `client` — the configured client is injected into each call.
+*
+* The return type stays `T` (= `typeof <StaticClass>`), so callers keep full
+* auto-complete and type checking on arguments and results.
+*/
+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;
+	} });
+};
+/**
+* The naturali.ai API client.
+*
+* Create one and reuse it; each property is a resource whose methods mirror
+* the generated SDK exactly, with the configured HTTP client already bound.
+*
+* ```ts
+* import { NaturaliClient } from '@naturali/sdk';
+*
+* const naturali = new NaturaliClient({
+*   baseUrl: 'https://api.naturali.ai',
+*   token: process.env.NATURALI_TOKEN,
+* });
+*
+* const { data, error } = await naturali.sessions.addSessionMessage({
+*   path: { project_id: PROJECT_ID, agent_id: AGENT_ID, session_id: SESSION_ID },
+*   body: { role: 'user', content: 'What is the capital of France?' },
+* });
+* ```
+*
+* Every method resolves to `{ data, error }` rather than throwing on a non-2xx
+* response, so the platform's error envelope (`{ error: { code, message } }`)
+* is available as typed data.
+*/
+var NaturaliClient = class {
+	agents;
+	apiKeys;
+	auth;
+	channels;
+	contacts;
+	generations;
+	knowledge;
+	models;
+	projects;
+	providers;
+	sessions;
+	tools;
+	traces;
+	/** The underlying HTTP client, for interceptors or one-off requests. */
+	http;
+	constructor({ baseUrl, token, headers } = {}) {
+		this.http = createClient(createConfig({
+			baseUrl: baseUrl ?? "",
+			headers: {
+				...token ? { Authorization: `Bearer ${token}` } : {},
+				...headers
+			}
+		}));
+		this.agents = bindResource(Agents, this.http);
+		this.apiKeys = bindResource(ApiKeys, this.http);
+		this.auth = bindResource(Auth, this.http);
+		this.channels = bindResource(Channels, this.http);
+		this.contacts = bindResource(Contacts, this.http);
+		this.generations = bindResource(Generations, this.http);
+		this.knowledge = bindResource(Knowledge, this.http);
+		this.models = bindResource(Models, this.http);
+		this.projects = bindResource(Projects, this.http);
+		this.providers = bindResource(Providers, this.http);
+		this.sessions = bindResource(Sessions, this.http);
+		this.tools = bindResource(Tools, this.http);
+		this.traces = bindResource(Traces, this.http);
+	}
+};
+//#endregion
+export { Agents, ApiKeys, Auth, Channels, Contacts, Generations, Knowledge, Models, NaturaliClient, Projects, Providers, Sessions, Tools, Traces, createClient, createConfig };