codai-sdk 0.29.0 → 0.54.1

package/dist/index.js

@@ -257,6 +257,14 @@ function sleep(ms) {
 	return new Promise((r) => setTimeout(r, ms));
 }
 
+//#endregion
+//#region src/resources/_shared.ts
+function stripUndefined(obj) {
+	const out = {};
+	for (const [k, v] of Object.entries(obj)) if (v !== void 0) out[k] = v;
+	return out;
+}
+
 //#endregion
 //#region src/resources/account.ts
 var Account = class {
@@ -555,6 +563,65 @@ var Audio = class {
 	}
 };
 
+//#endregion
+//#region src/resources/billing.ts
+var Billing = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** `GET /v1/billing` — plan, wallet, auto top-up, cards and pay links (read-only). */
+	get(opts = {}) {
+		return this.http.json("/v1/billing", {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `GET /v1/billing/invoices` — fiscal invoices and credit notes, newest first. */
+	async invoices(query = {}, opts = {}) {
+		return [...(await this.http.json("/v1/billing/invoices", {
+			query: { limit: query.limit },
+			ext: opts.ext,
+			signal: opts.signal
+		})).invoices];
+	}
+	/**
+	* Poll `get()` every `intervalMs` and call `onLow` once each time the wallet
+	* balance crosses below `thresholdEur`. Read-only: never creates a checkout.
+	* Returns a function that stops the watcher.
+	*/
+	watchBalance(opts) {
+		const intervalMs = Math.max(1e3, opts.intervalMs ?? 6e4);
+		const ctrl = new AbortController();
+		const stop = () => ctrl.abort();
+		if (opts.signal) {
+			if (opts.signal.aborted) stop();
+			else opts.signal.addEventListener("abort", stop, { once: true });
+		}
+		let low = false;
+		let timer;
+		const tick = async () => {
+			if (ctrl.signal.aborted) return;
+			try {
+				const billing = await this.get({ signal: ctrl.signal });
+				const balance = billing.wallet.balance_eur;
+				if (balance < opts.thresholdEur) {
+					if (!low) {
+						low = true;
+						await opts.onLow(balance, billing);
+					}
+				} else low = false;
+			} catch (err) {
+				if (!ctrl.signal.aborted) opts.onError?.(err);
+			}
+			if (!ctrl.signal.aborted) timer = setTimeout(() => void tick(), intervalMs);
+		};
+		ctrl.signal.addEventListener("abort", () => clearTimeout(timer), { once: true });
+		tick();
+		return stop;
+	}
+};
+
 //#endregion
 //#region src/resources/cards.ts
 var Cards = class {
@@ -608,6 +675,29 @@ var Cards = class {
 		return this.get("/v1/cards/fx", params, opts);
 	}
 	/**
+	* `GET /v1/cards/route` — travel time from Google Routes: `route` { mode, durationS, staticDurationS, distanceM,
+	* polyline } and a `map` block. `origin`/`destination` as "lat,lng" or `from`/`to` as addresses; `mode` drive
+	* (traffic-aware, default), walk, bicycle, transit, two_wheeler. Billed per call; both null when no route exists.
+	*/
+	route(params, opts = {}) {
+		return this.get("/v1/cards/route", params, opts);
+	}
+	/**
+	* `GET /v1/cards/track` — parcel history as a `timeline` block plus `result` (carrier, configured, found,
+	* delivered, events, trackingUrl). `carrier` (sameday | fan | cargus | dpd) is guessed from the AWB when omitted;
+	* carriers without gateway credentials answer `configured: false` with only the tracking link. Free.
+	*/
+	track(params, opts = {}) {
+		return this.get("/v1/cards/track", params, opts);
+	}
+	/**
+	* `GET /v1/cards/efactura` — your fiscal documents issued through Brivio with their ANAF e-Factura status
+	* (`documents[]` + a `table` block, null when there are none). Free.
+	*/
+	efactura(params = {}, opts = {}) {
+		return this.get("/v1/cards/efactura", params, opts);
+	}
+	/**
 	* `POST /v1/cards/unfurl` — `links` block (variant `preview`) for a public https page; SSRF-guarded, cached 24 h.
 	* Private targets throw 400 `unfurl_blocked`, non-https pages 422 `unfurl_not_https`.
 	*/
@@ -620,6 +710,44 @@ var Cards = class {
 			signal: opts.signal
 		});
 	}
+	/**
+	* `POST /v1/cards/product` — `products` block with one item from a public https product page's schema.org
+	* `Product` JSON-LD (or OpenGraph product tags): name, image, price + currency (lowest offer), old price, rating
+	* (0–5), reviews, seller, availability badge in `lang` (en default). Only what the page states; never sponsored.
+	* SSRF-guarded like `unfurl`, cached 6 h. No product data throws 422 `product_not_found`.
+	*/
+	product(url, lang, opts = {}) {
+		const body = lang ? {
+			url,
+			lang
+		} : { url };
+		return this.http.json("/v1/cards/product", {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* `POST /v1/cards/render` — renders a `chart` or `qr` block to `format` (`png` default, or `svg`) at
+	* `width` x `height` CSS px (64–1200, defaults 480 x 300; QR is square) times `scale` (1–3, PNG only).
+	* Other block types (Mermaid `diagram`, `math`, …) throw 422 `render_unsupported`. Free; 2000 renders per day.
+	*/
+	async render(body, opts = {}) {
+		const res = await this.http.request("/v1/cards/render", {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal
+		});
+		const size = /^(\d+)x(\d+)$/.exec(res.headers.get("x-codai-render-size") ?? "");
+		return {
+			bytes: new Uint8Array(await res.arrayBuffer()),
+			contentType: res.headers.get("content-type") ?? "image/png",
+			width: size ? Number(size[1]) : null,
+			height: size ? Number(size[2]) : null
+		};
+	}
 };
 
 //#endregion
@@ -847,6 +975,8 @@ var Embeddings = class {
 //#endregion
 //#region src/resources/environments.ts
 const envPath = (id, suffix = "") => `/v1/environments/${encodeURIComponent(id)}${suffix}`;
+/** Absolute environment path → `/files/<each segment URL-encoded>`. */
+const filePath$1 = (path) => path.replace(/^\/+/, "").split("/").map((s) => encodeURIComponent(s)).join("/");
 var EnvironmentMembers = class {
 	http;
 	constructor(http) {
@@ -936,6 +1066,68 @@ var EnvironmentTasks = class {
 		});
 	}
 };
+/** `/v1/environments/{id}/files` — read/write/list over the relay (developer role or higher). */
+var EnvironmentFiles = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** `GET /v1/environments/{id}/files?path=` — directory entries; no path → your workspace. */
+	list(envId, path, opts = {}) {
+		return this.http.json(envPath(envId, "/files"), {
+			query: { path },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `GET /v1/environments/{id}/files/{path}` — UTF-8 text (64 KB default, `maxBytes` ≤ 512 KB). */
+	get(envId, path, options = {}) {
+		return this.http.json(envPath(envId, `/files/${filePath$1(path)}`), {
+			query: { max_bytes: options.maxBytes },
+			ext: options.ext,
+			signal: options.signal
+		});
+	}
+	/** `PUT /v1/environments/{id}/files/{path}` — replace with UTF-8 text (≤ 2 MB). */
+	put(envId, path, content, opts = {}) {
+		return this.http.json(envPath(envId, `/files/${filePath$1(path)}`), {
+			method: "PUT",
+			rawBody: content,
+			headers: { "Content-Type": "text/plain; charset=utf-8" },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+};
+/** `/v1/environments/{id}/jobs` — background jobs on the environment daemon. */
+var EnvironmentJobs = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** `POST /v1/environments/{id}/jobs` — returns at once with `job_id`. */
+	start(envId, body, opts = {}) {
+		return this.http.json(envPath(envId, "/jobs"), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** `GET /v1/environments/{id}/jobs/{jobId}` — status + output (`since` = previous `next_offset`). */
+	get(envId, jobId, query = {}, opts = {}) {
+		return this.http.json(envPath(envId, `/jobs/${encodeURIComponent(String(jobId))}`), {
+			query: {
+				since: query.since,
+				tail: query.tail,
+				session: query.session
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+};
 var EnvironmentPorts = class {
 	http;
 	constructor(http) {
@@ -1003,12 +1195,29 @@ var Environments = class {
 	ports;
 	secrets;
 	tasks;
+	files;
+	jobs;
 	constructor(http) {
 		this.http = http;
 		this.members = new EnvironmentMembers(http);
 		this.ports = new EnvironmentPorts(http);
 		this.secrets = new EnvironmentSecrets(http);
 		this.tasks = new EnvironmentTasks(http);
+		this.files = new EnvironmentFiles(http);
+		this.jobs = new EnvironmentJobs(http);
+	}
+	/**
+	* `POST /v1/environments/{id}/exec` — run one relay op and wait (developer+). `op` defaults to
+	* `shell` with `command`; 409 `environment_offline`, 504 `host_timeout`.
+	*/
+	exec(envId, body, opts = {}) {
+		return this.http.json(envPath(envId, "/exec"), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
 	}
 	/** `GET /v1/environments/{id}/ssh-ca` — CA public keys to trust (`@cert-authority` lines). */
 	sshCa(envId, opts = {}) {
@@ -1359,7 +1568,7 @@ function decodeBase64(b64) {
 	for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
 	return out;
 }
-function abortableSleep$2(ms, signal) {
+function abortableSleep$4(ms, signal) {
 	return new Promise((resolve, reject) => {
 		if (signal?.aborted) return reject(signal.reason ?? /* @__PURE__ */ new Error("Aborted"));
 		const t = setTimeout(() => {
@@ -1474,7 +1683,7 @@ var Videos = class {
 			}
 			if (st.status === "failed" || st.status === "filtered") throw new Error(`codai video job ${st.status}: ${st.error ?? "no details"}`);
 			if (Date.now() + pollIntervalMs > deadline) throw new Error(`codai video job ${job.id} did not finish within ${timeoutMs} ms`);
-			await abortableSleep$2(pollIntervalMs, signal);
+			await abortableSleep$4(pollIntervalMs, signal);
 		}
 	}
 };
@@ -1495,14 +1704,56 @@ var Renders = class {
 	/**
 	* Poll a render (`GET /v1/studio/renders/{id}`). Billed exactly once (final $0.01 / s, min $0.05; draft half) on the
 	* first poll that sees the finished render; failed renders cost nothing.
+	* `expandAssets` signs the timeline's scene and narration assets (`?expand=assets`).
 	*/
 	async retrieve(id, opts = {}) {
 		return await (await this.http.request(`/v1/studio/renders/${encodeURIComponent(id)}`, {
 			method: "GET",
+			query: { expand: opts.expandAssets ? "assets" : void 0 },
+			ext: opts.ext,
+			signal: opts.signal
+		})).json();
+	}
+	/**
+	* List renders newest first (`GET /v1/studio/renders`) — no polling, no signed URLs. `rootRenderId` restricts the
+	* list to one timeline's version chain; pass `next_before` as `before` for the next page.
+	*/
+	async list(params = {}, opts = {}) {
+		return await (await this.http.request("/v1/studio/renders", {
+			method: "GET",
+			query: {
+				before: params.before,
+				limit: params.limit,
+				root_render_id: params.rootRenderId
+			},
 			ext: opts.ext,
 			signal: opts.signal
 		})).json();
 	}
+	/**
+	* Render a scene timeline (`POST /v1/studio/timelines`, HTTP 202): image/video scenes, optional narration (billed
+	* now, `narration_cost_micro_usd`) and music. Poll with `retrieve(id)`; the render is billed once when it succeeds.
+	*/
+	async createTimeline(body, opts = {}) {
+		return await (await this.http.request("/v1/studio/timelines", {
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		})).json();
+	}
+	/**
+	* Regenerate one scene (`POST /v1/studio/renders/{id}/scenes/{sceneId}/regenerate`, HTTP 202): a NEW render with
+	* `parent_render_id` = `renderId`; the source must be a succeeded timeline render (409 `not_a_timeline`).
+	*/
+	async regenerateScene(renderId, sceneId, body, opts = {}) {
+		return await (await this.http.request(`/v1/studio/renders/${encodeURIComponent(renderId)}/scenes/${encodeURIComponent(sceneId)}/regenerate`, {
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		})).json();
+	}
 	/** Queue a render and poll until it succeeds. Throws on `failed` or timeout. */
 	async render(body, opts = {}) {
 		const { pollIntervalMs = 5e3, timeoutMs = 9e5, signal, ext } = opts;
@@ -1531,14 +1782,14 @@ var Renders = class {
 			}
 			if (st.status === "failed") throw new Error(`codai render failed: ${st.error ?? "no details"}`);
 			if (Date.now() + pollIntervalMs > deadline) throw new Error(`codai render ${job.id} did not finish within ${timeoutMs} ms`);
-			await abortableSleep$2(pollIntervalMs, signal);
+			await abortableSleep$4(pollIntervalMs, signal);
 		}
 	}
 };
 
 //#endregion
 //#region src/resources/documents.ts
-function abortableSleep$1(ms, signal) {
+function abortableSleep$3(ms, signal) {
 	return new Promise((resolve, reject) => {
 		if (signal?.aborted) return reject(signal.reason ?? /* @__PURE__ */ new Error("Aborted"));
 		const t = setTimeout(() => {
@@ -1631,7 +1882,7 @@ var Documents = class {
 			if (st.status === "succeeded") return st;
 			if (st.status === "failed") throw new Error(`codai document preview failed: ${st.error ?? "no details"}`);
 			if (Date.now() + pollIntervalMs > deadline) throw new Error(`codai document preview ${job.id} did not finish within ${timeoutMs} ms`);
-			await abortableSleep$1(pollIntervalMs, signal);
+			await abortableSleep$3(pollIntervalMs, signal);
 		}
 	}
 	/** Queue a deck video and poll `renders.retrieve` until it succeeds. Throws on `failed` or timeout. */
@@ -1663,128 +1914,1203 @@ var Documents = class {
 			}
 			if (st.status === "failed") throw new Error(`codai deck video failed: ${st.error ?? "no details"}`);
 			if (Date.now() + pollIntervalMs > deadline) throw new Error(`codai deck video ${accepted.id} did not finish within ${timeoutMs} ms`);
-			await abortableSleep$1(pollIntervalMs, signal);
+			await abortableSleep$3(pollIntervalMs, signal);
 		}
 	}
 };
 
 //#endregion
-//#region src/resources/messages.ts
-/** `POST /v1/messages` — Anthropic Messages wire (JSON + named-event SSE). */
-var Messages = class {
+//#region src/resources/exports.ts
+const path$4 = (id) => `/v1/studio/exports/${encodeURIComponent(id)}`;
+function abortableSleep$2(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(signal.reason ?? /* @__PURE__ */ new Error("Aborted"));
+		const t = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(t);
+			reject(signal?.reason ?? /* @__PURE__ */ new Error("Aborted"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+var Exports = class {
 	http;
 	constructor(http) {
 		this.http = http;
 	}
-	async create(body, opts = {}) {
-		const res = await this.http.request("/v1/messages", {
-			body: {
-				...body,
-				model: body.model ?? "codai",
-				stream: false
-			},
+	/** The export: `queued` / `running`, then `succeeded` (signed `url`, valid 1 h) or `failed` (`error`). Free. */
+	retrieve(id, opts = {}) {
+		return this.http.json(path$4(id), {
 			ext: opts.ext,
 			signal: opts.signal
 		});
-		const raw = await res.json();
-		return {
-			text: (raw.content ?? []).map((b) => b.type === "text" && typeof b.text === "string" ? b.text : "").join(""),
-			raw,
-			requestId: res.headers.get("x-codai-trace-id") ?? res.headers.get("x-request-id"),
-			routedTo: res.headers.get("x-codai-routed-to"),
-			headers: res.headers
-		};
 	}
-	stream(body, opts = {}) {
-		const requestPromise = this.http.request("/v1/messages", {
-			body: {
-				...body,
-				model: body.model ?? "codai",
-				stream: true
-			},
-			ext: opts.ext,
-			signal: opts.signal,
-			timeoutMs: 0,
-			noRetry: true
-		});
-		let resolveFinal;
-		let rejectFinal;
-		const final = new Promise((resolve, reject) => {
-			resolveFinal = resolve;
-			rejectFinal = reject;
-		});
-		final.catch(() => {});
-		let text = "";
-		let stopReason = null;
-		let inputTokens = null;
-		let outputTokens = null;
-		let res = null;
-		async function* events() {
-			try {
-				res = await requestPromise;
-				for await (const frame of readSse(res, opts.signal)) {
-					const ev = frameJson(frame);
-					if (!ev) continue;
-					if (typeof ev.type !== "string") ev.type = frame.event;
-					if (ev.type === "message_start") {
-						const usage = ev.message?.usage;
-						if (usage?.input_tokens !== void 0) inputTokens = usage.input_tokens;
-					} else if (ev.type === "content_block_delta") {
-						const delta = ev.delta;
-						if (delta?.type === "text_delta" && typeof delta.text === "string") text += delta.text;
-					} else if (ev.type === "message_delta") {
-						const delta = ev.delta;
-						if (delta?.stop_reason) stopReason = delta.stop_reason;
-						const usage = ev.usage;
-						if (usage?.output_tokens !== void 0) outputTokens = usage.output_tokens;
-					}
-					yield ev;
-					if (ev.type === "message_stop") break;
-				}
-				resolveFinal({
-					text,
-					stopReason,
-					usage: inputTokens !== null || outputTokens !== null ? {
-						inputTokens: inputTokens ?? 0,
-						outputTokens: outputTokens ?? 0
-					} : null,
-					requestId: res.headers.get("x-codai-trace-id") ?? res.headers.get("x-request-id") ?? null,
-					routedTo: res.headers.get("x-codai-routed-to"),
-					headers: res.headers
-				});
-			} catch (err) {
-				rejectFinal(err);
-				throw err;
-			}
-		}
-		async function* textOnly() {
-			for await (const ev of events()) {
-				if (ev.type !== "content_block_delta") continue;
-				const delta = ev.delta;
-				if (delta?.type === "text_delta" && delta.text) yield delta.text;
-			}
+	/**
+	* Poll `retrieve` every `intervalMs` (default 3 s) until the export is `succeeded` or `failed` and resolve with it
+	* (a `failed` export resolves too — check `status` / `error`). Throws when it is not done within `timeoutMs`
+	* (default 15 min) or when `signal` aborts.
+	*/
+	async wait(id, opts = {}) {
+		const { intervalMs = 3e3, timeoutMs = 9e5, signal, ext } = opts;
+		const deadline = Date.now() + timeoutMs;
+		for (;;) {
+			const st = await this.retrieve(id, {
+				ext,
+				signal
+			});
+			if (st.status === "succeeded" || st.status === "failed") return st;
+			if (Date.now() + intervalMs > deadline) throw new Error(`codai export ${id} did not finish within ${timeoutMs} ms`);
+			await abortableSleep$2(intervalMs, signal);
 		}
-		return {
-			[Symbol.asyncIterator]: () => events(),
-			text: () => ({ [Symbol.asyncIterator]: () => textOnly() }),
-			final
-		};
 	}
 };
 
 //#endregion
-//#region src/resources/models.ts
-var Models = class {
+//#region src/resources/creatives.ts
+const path$3 = (id, tail = "") => `/v1/studio/creatives/${encodeURIComponent(id)}${tail}`;
+const lottieQuery = (q) => ({
+	format: q.format,
+	formats: q.formats,
+	seq: q.seq,
+	container: q.container
+});
+var Creatives = class {
 	http;
 	constructor(http) {
 		this.http = http;
 	}
-	/** Every model the calling key may address (OpenAI list shape, `data[]`). */
-	async list(opts = {}) {
-		return [...(await this.http.json("/v1/models", {
+	/** List your creatives, most recently updated first (`next_before` pages). */
+	list(query = {}, opts = {}) {
+		return this.http.json("/v1/studio/creatives", {
+			query: {
+				kind: query.kind,
+				before: query.before,
+				limit: query.limit
+			},
 			ext: opts.ext,
 			signal: opts.signal
-		})).data ?? []];
+		});
+	}
+	/**
+	* Create a creative (`kind` + optional `title` / `doc`); without `doc` you get an empty document for the kind.
+	* `brand_kit_id` applies one of your brand kits (`brandKits`) to version 1: `brand = { kitId, tokens }` + its logo.
+	* `template` (+ `vars`, values by var key) starts from one of your templates (`templates`) instead of `doc`.
+	*/
+	create(body, opts = {}) {
+		return this.http.json("/v1/studio/creatives", {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** The document at the head (or `seq`) with signed `assets` (1 h URLs). */
+	retrieve(id, query = {}, opts = {}) {
+		return this.http.json(path$3(id), {
+			query: { seq: query.seq },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Compact text outline (+ formats and vars) — the cheapest structure for a prompt. */
+	outline(id, opts = {}) {
+		return this.http.json(path$3(id, "/outline"), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Node ids matching `query` (a string = text/name/id substring, or `{ text, type, sceneId, assetId, locked }`). */
+	find(id, query, opts = {}) {
+		return this.http.json(path$3(id, "/find"), {
+			method: "POST",
+			body: { query },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Full JSON of `ids` (scene ids return whole scenes) or of one `sceneId`. */
+	subtree(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/subtree"), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Apply an op batch (all or nothing) authored against `baseSeq`. A stale base is rebased when the touched
+	* targets did not change meanwhile; otherwise the call throws `CodaiError` 409 `stale` (reload and retry). Rejected
+	* ops throw 400 with `code` (`invalid`, `not_found`, `locked`, `duplicate_id`).
+	*/
+	edit(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/ops"), {
+			method: "POST",
+			body: {
+				base_seq: body.baseSeq,
+				ops: body.ops,
+				...body.intent !== void 0 ? { intent: body.intent } : {},
+				...body.author !== void 0 ? { author: body.author } : {},
+				...body.force !== void 0 ? { force: body.force } : {}
+			},
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** Version history, newest first (`beforeSeq` pages). */
+	versions(id, query = {}, opts = {}) {
+		return this.http.json(path$3(id, "/versions"), {
+			query: {
+				before_seq: query.beforeSeq,
+				limit: query.limit
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** New head whose document is version `seq`'s (undo / redo). */
+	revert(id, seq, opts = {}) {
+		return this.http.json(path$3(id, "/revert"), {
+			method: "POST",
+			body: { seq },
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** New creative from version `seq` (default the head). */
+	fork(id, body = {}, opts = {}) {
+		return this.http.json(path$3(id, "/fork"), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** Soft-delete the creative. */
+	delete(id, opts = {}) {
+		return this.http.json(path$3(id), {
+			method: "DELETE",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Contrast, safe area, empty text, missing assets, brand colours, platform safe zones and text floors, alt text,
+	* missing captions, reading speed, flashing, missing / stale translations. Issues carry `format` / `fixable` /
+	* `locale`; `fixable` counts them (`lintFix`). `locale` lints the translated document (adds
+	* `text_overflow_locale`); 404 `Locale not found.` for an unknown locale.
+	*/
+	lint(id, body = {}, opts = {}) {
+		return this.http.json(path$3(id, "/lint"), {
+			method: "POST",
+			...body.locale !== void 0 ? { body: { locale: body.locale } } : {},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Preview HTML (signed asset URLs) for `format` / one `scene` / a translation (`locale`). */
+	compiled(id, query = {}, opts = {}) {
+		return this.http.json(path$3(id, "/compiled"), {
+			query: {
+				format: query.format,
+				scene: query.scene,
+				locale: query.locale
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Queue an MP4 render of the head (`codai-render`, HTTP 202, `cached: false`); poll `renders.retrieve(render_id)`.
+	* When the same render already exists for this version / format / quality / fps you get it back at once
+	* (HTTP 200, `cached: true`, `status: 'succeeded'`, no new charge). Unchanged scenes are reused either way.
+	* `locale` renders a translation (404 `Locale not found.` when the creative has no such locale).
+	* `ai_label` (`none` | `corner` | `end_card`, EU AI Act art. 50(4)) burns a visible AI label into the video; omitted =
+	* `corner` when the creative uses TTS narration or AI images, else `none` (`none` with narration: 400 `ai_label_required`).
+	*/
+	render(id, body = {}, opts = {}) {
+		return this.http.json(path$3(id, "/render"), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* PNG still frames at up to 6 times (`t_ms`). `exact: false` (default) screenshots the compiled HTML; `exact: true`
+	* cuts them from a draft render of the covering scenes. Waits up to ~90 s: frames (`status: 'succeeded'`) or a
+	* running job (`status: 'running'`) to poll with `frameJob(id, frame_job_id)`. Cached frames are free; 60 frame
+	* jobs per UTC day are free, then billed (`billed_micro_usd`).
+	*/
+	frame(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/frame"), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Turn a comment pinned on a frame (`t_ms`, optional `node_id` / `scene_id`) into an edit: one bounded `codai`
+	* model turn proposes ops, applied like `edit` against `base_seq` (rebased when possible, 409 `stale` else).
+	* 422 `no_edit` when the model made no edit (its answer in `error.text`); `apply: false` only proposes the ops.
+	* Token-metered like any `codai` text call.
+	*/
+	comment(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/comments"), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Generate A/B variants: one bounded `codai` model turn proposes `count` (default 3) variants changing only
+	* `focus` (default hook / title / cta); each becomes a fork of the creative at `base_seq` with the ops applied, plus
+	* a queued draft render (`render: false` to skip; poll `renders.retrieve(render_id)`). The original is unchanged
+	* until `pickVariant`. 422 `no_edit` when no valid variant came back, 504 `timeout` after 90 s. Token-metered.
+	*/
+	variants(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/variants"), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** The latest variant group of a creative (`group_id: null` when none) with statuses and stored render state. */
+	listVariants(id, opts = {}) {
+		return this.http.json(path$3(id, "/variants"), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Pick the winner: its ops are applied to the original against `base_seq` (rebased when possible, 409 `stale`
+	* else); the winner is marked `winner`, the rest of its group `rejected`.
+	*/
+	pickVariant(id, variantId, body, opts = {}) {
+		return this.http.json(path$3(id, `/variants/${encodeURIComponent(variantId)}/pick`), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Save the creative (at `seq`, default the head) as a private template: each `vars` entry turns a text node's text
+	* (`prop: 'text'`) or an image node's asset (`prop: 'image'`) into a variable whose default is the current value.
+	* 400 `node_not_found` / `invalid_pick` / `duplicate_key`. Free.
+	*/
+	saveTemplate(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/template"), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Queue an FCPXML export of a video creative (`seq`, default the head; `format`, default the first 1920×1080 /
+	* 1080×1920 / 1080×1080 format): a zip with `project.fcpxml` + per-scene MP4 segments + audio, for Final Cut Pro,
+	* DaVinci Resolve or Premiere. Resolves to the queued export; poll it with `exports.wait(e.id)`. Only newly
+	* rendered seconds are billed (final render price). 400 `unsupported_kind` / `unsupported_format` / `too_long`.
+	*/
+	exportFcpxml(id, query = {}, opts = {}) {
+		return this.http.json(path$3(id, "/export.fcpxml"), {
+			query: {
+				format: query.format,
+				seq: query.seq
+			},
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Export a video creative as a Lottie animation (`seq`, default the head; `format`, default the document's default
+	* format, or `formats: 'all'`; `container: 'json'` (default, Bodymovin JSON with embedded images) or `'dotlottie'`).
+	* Free and synchronous: resolves to an export that is already `succeeded` with a signed `url` (valid 1 h) and the
+	* fidelity report in `warnings` (video, chart, HTML block, table, cell grid and audio nodes are not exported).
+	* 400 `unsupported_kind` / `invalid_request`, 413 `too_large` (over 20 MB).
+	*/
+	exportLottie(id, query = {}, opts = {}) {
+		return this.http.json(path$3(id, "/export.lottie"), {
+			query: lottieQuery(query),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* The Lottie file itself (`download=1`, nothing stored): `application/json` for one Bodymovin JSON, `application/zip`
+	* for a dotLottie archive or a zip of JSON files (`formats: 'all'`). Same options and errors as `exportLottie`. Free.
+	*/
+	async downloadLottie(id, query = {}, opts = {}) {
+		const res = await this.http.request(path$3(id, "/export.lottie"), {
+			query: {
+				...lottieQuery(query),
+				download: "1"
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+		const m = /filename="([^"]+)"/i.exec(res.headers.get("content-disposition") ?? "");
+		return {
+			bytes: new Uint8Array(await res.arrayBuffer()),
+			filename: m ? m[1] : null,
+			contentType: res.headers.get("content-type")
+		};
+	}
+	/**
+	* Turn one of your Studio documents (deck, doc, sheet) into an editable creative — slides become scenes with a
+	* `layout` and speaker `notes`, doc pages a `flow` group, sheets a `cell_grid`; nodes carry semantic `role`s.
+	* Idempotent: a document that already has a creative resolves to it (`existing: true`). Free. 404 unknown document,
+	* 409 `document_spec_missing`, 400 `invalid_spec`, 413 `too_large`.
+	*/
+	fromDocument(documentId, opts = {}) {
+		return this.http.json(`/v1/studio/documents/${encodeURIComponent(documentId)}/creative`, {
+			method: "POST",
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Build a deck / doc / sheet creative (at `seq`, default the head) into a PPTX / DOCX / XLSX — a new version of its
+	* Studio document (`document`, exactly the `POST /v1/studio/documents` body). Converter notes come back in
+	* `warnings`. The file is free; `preview: true` also queues a billed preview (poll it with
+	* `documents.waitForPreview`). 400 `not_supported_for_kind` (video / image) or `invalid_spec`.
+	*/
+	build(id, body = {}, opts = {}) {
+		return this.http.json(path$3(id, "/build"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Re-apply a brand kit (`brand_kit_id`) or a flat token map (`tokens`) to the creative as one new version: literal
+	* colours equal to the old brand become token refs, `snap: true` maps every other colour to the nearest kit colour,
+	* `fonts` (default true) sets heading / body font refs by role, locked nodes are skipped unless `force`. The kit
+	* logo is registered too. `base_seq` defaults to the head (rebased like `edit`, 409 `stale` else). Free.
+	*/
+	restyle(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/restyle"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Auto-captions: transcribe a voice clip (`clip_id`, default the first voice clip) word by word and add or update a
+	* captions node (`preset`, default `bold-pill`) as one new version. Words are cached on the asset (free next time
+	* unless `retranscribe`); `script` (default the narration of a codai speech asset) corrects the spelling. A fresh
+	* transcription is billed at the speech-to-text rate (`cost_micro_usd`). Video creatives only (400
+	* `unsupported_kind`); 403 `residency_unavailable`, 503 `transcription_unavailable`.
+	*/
+	captions(id, body = {}, opts = {}) {
+		return this.http.json(path$3(id, "/captions"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** The captions as SubRip text on the document timeline (`node_id`, `seq` optional); 404 without captions. Free. */
+	async captionsSrt(id, query = {}, opts = {}) {
+		return (await this.http.request(path$3(id, "/captions.srt"), {
+			query: {
+				node_id: query.node_id,
+				seq: query.seq,
+				locale: query.locale
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		})).text();
+	}
+	/** The captions as WebVTT text on the document timeline (`node_id`, `seq` optional); 404 without captions. Free. */
+	async captionsVtt(id, query = {}, opts = {}) {
+		return (await this.http.request(path$3(id, "/captions.vtt"), {
+			query: {
+				node_id: query.node_id,
+				seq: query.seq,
+				locale: query.locale
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		})).text();
+	}
+	/**
+	* Adapt to platforms (`tiktok`, `reels`, `shorts`, `feed-square`, `feed-portrait`, `youtube`): one format per
+	* platform in one new version, text kept inside each platform's safe zone and above its legible size.
+	* `focal: 'vision'` (token-metered) finds the focal point of full-bleed images; it fails open. Free otherwise.
+	*/
+	adapt(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/adapt"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Fix lint issues as one new version: deterministic fixes (free) for `off_brand_color`, `text_too_small`,
+	* `outside_platform_safe_zone` and `flashing` (`codes` limits them); `agent: true` (token-metered) gives the rest
+	* to one `codai` turn. Nothing to fix: the current `seq`, empty `fixed`, no new version.
+	*/
+	lintFix(id, body = {}, opts = {}) {
+		return this.http.json(path$3(id, "/lint/fix"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* The tweak panel model: one control per variable (stored `meta.controls` entry or derived from the type). Change
+	* values with a `setVar` op and controls with a `setControl` op (`edit`). Free.
+	*/
+	controls(id, opts = {}) {
+		return this.http.json(path$3(id, "/controls"), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Localisation state: source locale, glossary, unit count and per locale translated / missing / stale / voice.
+	* With `locale` (+ `units`, default 1) also the units of that locale (paged with `offset` / `limit` ≤ 500). Free.
+	*/
+	locales(id, query = {}, opts = {}) {
+		return this.http.json(path$3(id, "/locales"), {
+			query: {
+				locale: query.locale,
+				units: query.units,
+				offset: query.offset,
+				limit: query.limit
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Translate every text into up to 10 BCP-47 `locales` as per-locale overrides (one new version, author `agent`).
+	* Token-metered `codai` turns; `glossary` terms and the brand kit name stay verbatim, `tone` picks the address,
+	* `only_missing` (default true) skips fresh translations, `voice: true` (video, billed) narrates voice clips again.
+	* 400 `nothing_to_translate`; 503 `localize_unavailable` when every locale failed.
+	*/
+	localize(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/localize"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Save `locale` as a new standalone creative (translations applied, overrides dropped, `fork_of` recorded; default
+	* title `<title> (<locale>)`). 404 `Locale not found.`. Free (HTTP 201).
+	*/
+	forkLocale(id, locale, body = {}, opts = {}) {
+		return this.http.json(path$3(id, `/locales/${encodeURIComponent(locale)}/fork`), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Create a public link: `view` (read-only preview of version `seq` or the head; `allow_remix` default false) or
+	* `review` (comments by name, no account; `can_approve` lets the holder approve). The `token` and `url` are shown
+	* only in this answer (HTTP 201). 400 `unknown_seq`; 409 `too_many_shares` (20 active links). Free.
+	*/
+	createShare(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/shares"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** The active links (not revoked, not expired), newest first; `url` is always null. Free. */
+	listShares(id, opts = {}) {
+		return this.http.json(path$3(id, "/shares"), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Revoke a link: it answers 404 from now on. 404 when unknown or already revoked. Free. */
+	async revokeShare(id, shareId, opts = {}) {
+		await this.http.request(path$3(id, `/shares/${encodeURIComponent(shareId)}`), {
+			method: "DELETE",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* The review state: `status` (`draft` → `in_review` → `approved` | `changes_requested`), requested / approved
+	* version (`approved_is_head` false once the creative changed), decider and thread counts. Free.
+	*/
+	review(id, opts = {}) {
+		return this.http.json(path$3(id, "/review"), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Send the head to review (`in_review`, earlier decision cleared) so approver links can decide. Free. */
+	requestReview(id, opts = {}) {
+		return this.http.json(path$3(id, "/review"), {
+			method: "POST",
+			body: { action: "request" },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Back to `draft` (decision cleared, comments kept). Free. */
+	resetReview(id, opts = {}) {
+		return this.http.json(path$3(id, "/review"), {
+			method: "POST",
+			body: { action: "reset" },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Comment threads, newest first (≤ 200), replies oldest first; `status` `open` | `resolved` | `all`. Free. */
+	reviewThreads(id, query = {}, opts = {}) {
+		return this.http.json(path$3(id, "/review/threads"), {
+			query: { status: query.status },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Start a thread as the owner, optionally anchored to `node_id` / `scene_id` / `t_ms` (checked against the head:
+	* 400 `unknown_node` / `unknown_scene`; HTTP 201). 409 `too_many_comments`. Free.
+	*/
+	createReviewThread(id, body, opts = {}) {
+		return this.http.json(path$3(id, "/review/threads"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** Reply in a thread as the owner (HTTP 201) — returns the whole thread. Free. */
+	replyReviewThread(id, threadId, body, opts = {}) {
+		return this.http.json(path$3(id, `/review/threads/${encodeURIComponent(threadId)}/replies`), {
+			method: "POST",
+			body: { body: body.body },
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** Resolve a thread. Free. */
+	resolveReviewThread(id, threadId, opts = {}) {
+		return this.http.json(path$3(id, `/review/threads/${encodeURIComponent(threadId)}/resolve`), {
+			method: "POST",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Reopen a resolved thread. Free. */
+	reopenReviewThread(id, threadId, opts = {}) {
+		return this.http.json(path$3(id, `/review/threads/${encodeURIComponent(threadId)}/reopen`), {
+			method: "POST",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Delete any comment (owner moderation; deleting a root hides the thread). 404 when unknown. Free. */
+	async deleteReviewComment(id, commentId, opts = {}) {
+		await this.http.request(path$3(id, `/review/comments/${encodeURIComponent(commentId)}`), {
+			method: "DELETE",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Poll a frame job: frames when done (`status: 'succeeded'`), `status: 'running'` meanwhile; 404 unknown job. */
+	frameJob(id, jobId, opts = {}) {
+		return this.http.json(path$3(id, `/frames/${encodeURIComponent(jobId)}`), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+};
+
+//#endregion
+//#region src/resources/brand-kits.ts
+const path$2 = (id, tail = "") => `/v1/studio/brand-kits/${encodeURIComponent(id)}${tail}`;
+var BrandKits = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/**
+	* Create a kit you define: flat `tokens` (the 5 colours `#rrggbb`, optional fonts) or a DTCG document in `dtcg`
+	* (import) — exactly one. 400 `invalid_tokens` (with `details.issues`) for an invalid DTCG document, 404 when
+	* `logo_asset_id` is not one of your ready image assets. Free.
+	*/
+	create(body, opts = {}) {
+		return this.http.json("/v1/studio/brand-kits", {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Edit a kit: `tokens` is merged onto the current kit, `dtcg` replaces the whole document (not both),
+	* `logo_asset_id: null` removes the logo. Creatives keep their tokens until `creatives.restyle`. Free.
+	*/
+	update(id, body, opts = {}) {
+		return this.http.json(path$2(id), {
+			method: "PATCH",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** The kit as a DTCG 2025.10 JSON document (`$extensions['ro.codai']` = kit id, name, logo asset id). Free. */
+	exportDtcg(id, opts = {}) {
+		return this.http.json(path$2(id, "/dtcg"), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Extract a brand kit from a public `https` page (`{ url }`) or from one of your logo images
+	* (`{ logo_asset_id }`, PNG / JPEG / WebP up to 5 MB; it becomes the kit logo): palette (primary, secondary, accent,
+	* background, text) and heading / body fonts. One bounded `codai` model call (token-metered); 400 `url_blocked` for
+	* private hosts, 400 `unsupported_media` for a bad logo, 422 `fetch_failed` / `extract_failed`, 504 `timeout`.
+	*/
+	extract(body, opts = {}) {
+		return this.http.json("/v1/studio/brand-kits/extract", {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** Your brand kits, newest first (`limit` 1–100, default 50). Free. */
+	list(query = {}, opts = {}) {
+		return this.http.json("/v1/studio/brand-kits", {
+			query: { limit: query.limit },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** One kit with a signed logo URL (1 h), its `dtcg` and the WCAG `contrast` pairs. Free. */
+	retrieve(id, opts = {}) {
+		return this.http.json(path$2(id), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Delete a kit (creatives keep their tokens; the logo asset stays). Free. */
+	delete(id, opts = {}) {
+		return this.http.json(path$2(id), {
+			method: "DELETE",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+};
+
+//#endregion
+//#region src/resources/templates.ts
+const path$1 = (id) => `/v1/studio/templates/${encodeURIComponent(id)}`;
+var Templates = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** Your templates, newest first (`kind` filter, `limit` 1–100, default 50); without `doc`. Free. */
+	list(query = {}, opts = {}) {
+		return this.http.json("/v1/studio/templates", {
+			query: {
+				kind: query.kind,
+				limit: query.limit
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** One template with its variables and `doc`. Free. */
+	retrieve(id, opts = {}) {
+		return this.http.json(path$1(id), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Delete a template (creatives made from it are not affected). Free. */
+	delete(id, opts = {}) {
+		return this.http.json(path$1(id), {
+			method: "DELETE",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+};
+
+//#endregion
+//#region src/resources/batches.ts
+const BATCH_DONE = [
+	"completed",
+	"failed",
+	"cancelled"
+];
+const path = (id, tail = "") => `/v1/studio/batches/${encodeURIComponent(id)}${tail}`;
+function abortableSleep$1(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(signal.reason ?? /* @__PURE__ */ new Error("Aborted"));
+		const t = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(t);
+			reject(signal?.reason ?? /* @__PURE__ */ new Error("Aborted"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+var Batches = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/**
+	* Create a batch: rows are validated (invalid rows are stored as `failed`) and run in the background; poll `get`
+	* or `wait`. 400 `invalid_rows` when every row is invalid. Free (translations and renders are billed as usual).
+	*/
+	async create(body, opts = {}) {
+		return this.http.json("/v1/studio/batches", {
+			method: "POST",
+			body: stripUndefined({
+				...body,
+				dry_run: false
+			}),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** Validate only (`dry_run: true`): the mapping, row errors, a 3-row preview and an estimate; nothing stored. Free. */
+	dryRun(body, opts = {}) {
+		return this.http.json("/v1/studio/batches", {
+			method: "POST",
+			body: stripUndefined({
+				...body,
+				dry_run: true
+			}),
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Your batches, newest first (`limit` 1–50, `before` = the previous `next_before`). Free. */
+	list(query = {}, opts = {}) {
+		return this.http.json("/v1/studio/batches", {
+			query: {
+				limit: query.limit,
+				before: query.before
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** The batch (`rows: 1` adds rows; `status`, `offset`, `limit` ≤ 100). Each poll advances it a little. Free. */
+	get(id, query = {}, opts = {}) {
+		return this.http.json(path(id), {
+			query: {
+				rows: query.rows,
+				status: query.status,
+				offset: query.offset,
+				limit: query.limit
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Stop the batch; rows not started become `skipped`. 409 `not_cancellable` when already finished. Free. */
+	cancel(id, opts = {}) {
+		return this.http.json(path(id, "/cancel"), {
+			method: "POST",
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** Queue the failed rows again (≤ 3 attempts each). 409 `nothing_to_retry`. Free. */
+	retry(id, opts = {}) {
+		return this.http.json(path(id, "/retry"), {
+			method: "POST",
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** The original CSV plus `creative_id`, `status`, `error`, `render_url` per row (formula-safe). Free. */
+	async exportCsv(id, opts = {}) {
+		return (await this.http.request(path(id, "/export.csv"), {
+			ext: opts.ext,
+			signal: opts.signal
+		})).text();
+	}
+	/**
+	* Start building a ZIP of the finished renders (202, `zip.status: 'building'`; unchanged when already building or
+	* ready). Poll `get` until `zip.status` is `ready` (signed `zip.url`). 409 `no_renders`. Free.
+	*/
+	zip(id, opts = {}) {
+		return this.http.json(path(id, "/zip"), {
+			method: "POST",
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/**
+	* Poll `get` every `intervalMs` (default 3 s) until the batch is `completed`, `failed` or `cancelled` and resolve
+	* with it. Throws when it is not done within `timeoutMs` (default 10 min) or when `signal` aborts.
+	*/
+	async wait(id, opts = {}) {
+		const { intervalMs = 3e3, timeoutMs = 6e5, signal, ext } = opts;
+		const deadline = Date.now() + timeoutMs;
+		for (;;) {
+			const { batch } = await this.get(id, {}, {
+				ext,
+				signal
+			});
+			if (BATCH_DONE.includes(batch.status)) return batch;
+			if (Date.now() + intervalMs > deadline) throw new Error(`codai batch ${id} did not finish within ${timeoutMs} ms`);
+			await abortableSleep$1(intervalMs, signal);
+		}
+	}
+};
+
+//#endregion
+//#region src/resources/shares.ts
+const SHARE_TOKEN_RE = /^[A-Za-z0-9_-]{43}$/;
+/**
+* The share token in `input`: a raw token, or any `https://…/s/<token>` / `…/r/<token>` URL (query and fragment
+* ignored). Trims; `null` for anything else (same rule as the gateway and the apps).
+*/
+function shareTokenFrom(input) {
+	const s = input.trim();
+	if (SHARE_TOKEN_RE.test(s)) return s;
+	let url;
+	try {
+		url = new URL(s);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+	const parts = url.pathname.split("/").filter(Boolean);
+	if (parts.length < 2) return null;
+	const kind = parts[parts.length - 2];
+	const token = parts[parts.length - 1];
+	return (kind === "s" || kind === "r") && SHARE_TOKEN_RE.test(token) ? token : null;
+}
+function tokenOf(tokenOrUrl) {
+	const token = shareTokenFrom(tokenOrUrl);
+	if (!token) throw new TypeError("codai: not a share link or token (expected …/s/<token> or …/r/<token>)");
+	return token;
+}
+const review = (tokenOrUrl, tail) => `/v1/public/studio/reviews/${encodeURIComponent(tokenOf(tokenOrUrl))}${tail}`;
+const thread = (tokenOrUrl, threadId, tail) => review(tokenOrUrl, `/threads/${encodeURIComponent(threadId)}${tail}`);
+var Shares = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/**
+	* The shared creative: title, kind, version, formats, locales and the compiled preview HTML of `format` /
+	* `locale` (null for images); review links add the review state and every thread. 404 for unknown, revoked or
+	* expired links. No key needed.
+	*/
+	get(tokenOrUrl, query = {}, opts = {}) {
+		return this.http.json(`/v1/public/studio/shares/${encodeURIComponent(tokenOf(tokenOrUrl))}`, {
+			query: {
+				format: query.format,
+				locale: query.locale
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Copy the version a `view` link shows into a new creative of yours (the owner's ready assets are copied, the
+	* foreign brand kit dropped; HTTP 201). 404 for review links or links without remix; 413 `remix_too_large`. Free.
+	*/
+	remix(tokenOrUrl, body = {}, opts = {}) {
+		return this.http.json(`/v1/studio/shares/${encodeURIComponent(tokenOf(tokenOrUrl))}/remix`, {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** Start a thread through a review link (`name`, `body`, optional anchor; HTTP 201). 400 `invalid_name`. */
+	comment(tokenOrUrl, body, opts = {}) {
+		return this.http.json(review(tokenOrUrl, "/threads"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** Reply in a thread through a review link (`name`, `body`; HTTP 201) — returns the whole thread. */
+	reply(tokenOrUrl, threadId, body, opts = {}) {
+		return this.http.json(thread(tokenOrUrl, threadId, "/replies"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+	/** Resolve a thread through a review link (`resolved_by` = `name`). */
+	resolve(tokenOrUrl, threadId, body, opts = {}) {
+		return this.http.json(thread(tokenOrUrl, threadId, "/resolve"), {
+			method: "POST",
+			body: { name: body.name },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** Reopen a resolved thread through a review link. */
+	reopen(tokenOrUrl, threadId, body, opts = {}) {
+		return this.http.json(thread(tokenOrUrl, threadId, "/reopen"), {
+			method: "POST",
+			body: { name: body.name },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Approve or request changes (approver review links only). 403 `not_an_approver`, 409 `review_not_open`, 409
+	* `stale` (with `head_seq`) when `seq` is not the head. Returns the new review state.
+	*/
+	decide(tokenOrUrl, body, opts = {}) {
+		return this.http.json(review(tokenOrUrl, "/decision"), {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+};
+
+//#endregion
+//#region src/resources/voice-revocations.ts
+var VoiceRevocations = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** Store a takedown ticket for manual review (HTTP 202). Rate-limited per IP; never retried. */
+	create(body, opts = {}) {
+		return this.http.json("/v1/studio/voice-revocations", {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+};
+
+//#endregion
+//#region src/resources/abuse-reports.ts
+var AbuseReports = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** Store an abuse report for manual review (HTTP 202). Rate-limited per IP; never retried. */
+	create(body, opts = {}) {
+		return this.http.json("/v1/studio/abuse-reports", {
+			method: "POST",
+			body: stripUndefined(body),
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+};
+
+//#endregion
+//#region src/resources/provenance.ts
+/** Largest file the checker accepts (25 MB). */
+const PROVENANCE_MAX_BYTES = 26214400;
+var Provenance = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/**
+	* Upload `file` (PNG, JPEG, WebP, WAV, MP3 or MP4, ≤ 25 MB) and return what was found. A `Blob`/`File` sends its own
+	* `type`; raw bytes need `contentType` (default `application/octet-stream`). Never retried.
+	*/
+	check(file, opts = {}) {
+		const type = opts.contentType || (file instanceof Blob && file.type ? file.type : "application/octet-stream");
+		return this.http.json("/v1/public/provenance/check", {
+			method: "POST",
+			rawBody: file,
+			headers: { "Content-Type": type },
+			ext: opts.ext,
+			signal: opts.signal,
+			noRetry: true
+		});
+	}
+};
+
+//#endregion
+//#region src/resources/messages.ts
+/** `POST /v1/messages` — Anthropic Messages wire (JSON + named-event SSE). */
+var Messages = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	async create(body, opts = {}) {
+		const res = await this.http.request("/v1/messages", {
+			body: {
+				...body,
+				model: body.model ?? "codai",
+				stream: false
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+		const raw = await res.json();
+		return {
+			text: (raw.content ?? []).map((b) => b.type === "text" && typeof b.text === "string" ? b.text : "").join(""),
+			raw,
+			requestId: res.headers.get("x-codai-trace-id") ?? res.headers.get("x-request-id"),
+			routedTo: res.headers.get("x-codai-routed-to"),
+			headers: res.headers
+		};
+	}
+	stream(body, opts = {}) {
+		const requestPromise = this.http.request("/v1/messages", {
+			body: {
+				...body,
+				model: body.model ?? "codai",
+				stream: true
+			},
+			ext: opts.ext,
+			signal: opts.signal,
+			timeoutMs: 0,
+			noRetry: true
+		});
+		let resolveFinal;
+		let rejectFinal;
+		const final = new Promise((resolve, reject) => {
+			resolveFinal = resolve;
+			rejectFinal = reject;
+		});
+		final.catch(() => {});
+		let text = "";
+		let stopReason = null;
+		let inputTokens = null;
+		let outputTokens = null;
+		let res = null;
+		async function* events() {
+			try {
+				res = await requestPromise;
+				for await (const frame of readSse(res, opts.signal)) {
+					const ev = frameJson(frame);
+					if (!ev) continue;
+					if (typeof ev.type !== "string") ev.type = frame.event;
+					if (ev.type === "message_start") {
+						const usage = ev.message?.usage;
+						if (usage?.input_tokens !== void 0) inputTokens = usage.input_tokens;
+					} else if (ev.type === "content_block_delta") {
+						const delta = ev.delta;
+						if (delta?.type === "text_delta" && typeof delta.text === "string") text += delta.text;
+					} else if (ev.type === "message_delta") {
+						const delta = ev.delta;
+						if (delta?.stop_reason) stopReason = delta.stop_reason;
+						const usage = ev.usage;
+						if (usage?.output_tokens !== void 0) outputTokens = usage.output_tokens;
+					}
+					yield ev;
+					if (ev.type === "message_stop") break;
+				}
+				resolveFinal({
+					text,
+					stopReason,
+					usage: inputTokens !== null || outputTokens !== null ? {
+						inputTokens: inputTokens ?? 0,
+						outputTokens: outputTokens ?? 0
+					} : null,
+					requestId: res.headers.get("x-codai-trace-id") ?? res.headers.get("x-request-id") ?? null,
+					routedTo: res.headers.get("x-codai-routed-to"),
+					headers: res.headers
+				});
+			} catch (err) {
+				rejectFinal(err);
+				throw err;
+			}
+		}
+		async function* textOnly() {
+			for await (const ev of events()) {
+				if (ev.type !== "content_block_delta") continue;
+				const delta = ev.delta;
+				if (delta?.type === "text_delta" && delta.text) yield delta.text;
+			}
+		}
+		return {
+			[Symbol.asyncIterator]: () => events(),
+			text: () => ({ [Symbol.asyncIterator]: () => textOnly() }),
+			final
+		};
+	}
+};
+
+//#endregion
+//#region src/resources/models.ts
+var Models = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** Every model the calling key may address (OpenAI list shape, `data[]`). */
+	async list(opts = {}) {
+		return [...(await this.http.json("/v1/models", {
+			ext: opts.ext,
+			signal: opts.signal
+		})).data ?? []];
 	}
 };
 
@@ -2075,6 +3401,42 @@ var Realtime = class {
 	}
 };
 
+//#endregion
+//#region src/resources/referrals.ts
+var Referrals = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** `GET /v1/referrals` — stats, redeem deadline and invitees (masked, no PII). */
+	get(opts = {}) {
+		return this.http.json("/v1/referrals", {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* Redeem a referrer's code (their username) — `PATCH /v1/account
+	* { referral_code }`. Allowed within 7 days of signup; the outcome is in
+	* `referral_result` of the response.
+	*/
+	redeem(code, opts = {}) {
+		return this.patch({ referral_code: code }, opts);
+	}
+	/** Opt in/out of the referral programme — `PATCH /v1/account { referral_consent }`. */
+	setConsent(consent, opts = {}) {
+		return this.patch({ referral_consent: consent }, opts);
+	}
+	patch(body, opts) {
+		return this.http.json("/v1/account", {
+			method: "PATCH",
+			body,
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+};
+
 //#endregion
 //#region src/resources/resolve.ts
 /**
@@ -2313,6 +3675,38 @@ var Resolve = class {
 		return this.call(`/v1/resolve/jobs/${encodeURIComponent(id)}`, { signal: opts.signal });
 	}
 	/**
+	* `GET /v1/resolve/jobs` — one page of your jobs, newest first. Pass the
+	* page's `next_cursor` back as `cursor` for the next page (`null` = last).
+	* `status` filters by one or more statuses.
+	*/
+	list(query = {}, opts = {}) {
+		const status = Array.isArray(query.status) ? query.status.join(",") : query.status;
+		return this.call("/v1/resolve/jobs", {
+			query: {
+				status: status || void 0,
+				limit: query.limit,
+				cursor: query.cursor
+			},
+			signal: opts.signal
+		});
+	}
+	/**
+	* Every job matching `query`, newest first, following `next_cursor` page by
+	* page (`limit` = page size). Stop early with `break`.
+	*/
+	async *iterate(query = {}, opts = {}) {
+		let cursor;
+		for (;;) {
+			const page = await this.list({
+				...query,
+				cursor
+			}, opts);
+			for (const job of page.jobs) yield job;
+			if (!page.next_cursor) return;
+			cursor = page.next_cursor;
+		}
+	}
+	/**
 	* `POST /v1/resolve/jobs/{id}/accept` — accept a paid quote and start the job.
 	* The result's `paid_with` says how it was paid (`intro` €1 hold, `credit`
 	* t7 fix credit, or `wallet`). Throws `ResolveInsufficientFundsError` (402,
@@ -3058,7 +4452,7 @@ var Notifications = class {
 //#endregion
 //#region src/resources/prompts.ts
 /** `/v1/prompts/*` — pending prompts: ready-to-paste prompts left for a future chat (handoffs, follow-ups). */
-const one$2 = (id, suffix = "") => `/v1/prompts/${encodeURIComponent(id)}${suffix}`;
+const one$3 = (id, suffix = "") => `/v1/prompts/${encodeURIComponent(id)}${suffix}`;
 var Prompts = class {
 	http;
 	constructor(http) {
@@ -3086,14 +4480,14 @@ var Prompts = class {
 	}
 	/** `GET /v1/prompts/{id}`. */
 	get(id, opts = {}) {
-		return this.http.json(one$2(id), {
+		return this.http.json(one$3(id), {
 			ext: opts.ext,
 			signal: opts.signal
 		});
 	}
 	/** `PATCH /v1/prompts/{id}` — edit, snooze (`not_before`), close (`status: 'done' | 'dismissed'`). */
 	update(id, body, opts = {}) {
-		return this.http.json(one$2(id), {
+		return this.http.json(one$3(id), {
 			method: "PATCH",
 			body,
 			ext: opts.ext,
@@ -3102,7 +4496,7 @@ var Prompts = class {
 	}
 	/** `DELETE /v1/prompts/{id}` — `{ deleted: 0 }` when the id is missing or not yours. */
 	delete(id, opts = {}) {
-		return this.http.json(one$2(id), {
+		return this.http.json(one$3(id), {
 			method: "DELETE",
 			ext: opts.ext,
 			signal: opts.signal
@@ -3110,7 +4504,7 @@ var Prompts = class {
 	}
 	/** `POST /v1/prompts/{id}/launch` — new shared session + `send` control on a device; the prompt becomes `launched`. */
 	launch(id, deviceId, opts = {}) {
-		return this.http.json(one$2(id, "/launch"), {
+		return this.http.json(one$3(id, "/launch"), {
 			method: "POST",
 			body: deviceId ? { device_id: deviceId } : {},
 			ext: opts.ext,
@@ -3120,7 +4514,7 @@ var Prompts = class {
 	}
 	/** `POST /v1/prompts/{id}/match` — the prompt was sent in a chat → `sent` (or `answered`); never downgrades. */
 	match(id, body, opts = {}) {
-		return this.http.json(one$2(id, "/match"), {
+		return this.http.json(one$3(id, "/match"), {
 			method: "POST",
 			body,
 			ext: opts.ext,
@@ -3132,7 +4526,7 @@ var Prompts = class {
 	* events) and an optional diff; verdict `done` → `verified`. 502 when the model call fails.
 	*/
 	verify(id, body = {}, opts = {}) {
-		return this.http.json(one$2(id, "/verify"), {
+		return this.http.json(one$3(id, "/verify"), {
 			method: "POST",
 			body,
 			ext: opts.ext,
@@ -3167,7 +4561,7 @@ var Prompts = class {
 //#endregion
 //#region src/resources/schedules.ts
 /** `/v1/schedules/*`, `/v1/schedule-runs/*`, `/v1/scheduler/*` — the codai Scheduler (ADR 0006). */
-const one$1 = (id, suffix = "") => `/v1/schedules/${encodeURIComponent(id)}${suffix}`;
+const one$2 = (id, suffix = "") => `/v1/schedules/${encodeURIComponent(id)}${suffix}`;
 const run = (id, suffix) => `/v1/schedule-runs/${encodeURIComponent(id)}${suffix}`;
 /** Host-side executor protocol: claim → heartbeat → result. Needs a device header (`device` client option). */
 var ScheduleExecutor = class {
@@ -3209,7 +4603,7 @@ var ScheduleExecutor = class {
 	}
 	/** `POST /v1/schedules/{id}/approve-command` — this host approves the exact shell command hash it showed the user. */
 	approveCommand(scheduleId, commandHash, opts = {}) {
-		return this.http.json(one$1(scheduleId, "/approve-command"), {
+		return this.http.json(one$2(scheduleId, "/approve-command"), {
 			method: "POST",
 			body: { command_hash: commandHash },
 			ext: opts.ext,
@@ -3318,14 +4712,14 @@ var Schedules = class {
 	}
 	/** `GET /v1/schedules/{id}`. */
 	get(id, opts = {}) {
-		return this.http.json(one$1(id), {
+		return this.http.json(one$2(id), {
 			ext: opts.ext,
 			signal: opts.signal
 		});
 	}
 	/** `PATCH /v1/schedules/{id}` — partial; a changed shell command clears host approvals. */
 	update(id, body, opts = {}) {
-		return this.http.json(one$1(id), {
+		return this.http.json(one$2(id), {
 			method: "PATCH",
 			body,
 			ext: opts.ext,
@@ -3334,7 +4728,7 @@ var Schedules = class {
 	}
 	/** `DELETE /v1/schedules/{id}`. */
 	async delete(id, opts = {}) {
-		await this.http.request(one$1(id), {
+		await this.http.request(one$2(id), {
 			method: "DELETE",
 			ext: opts.ext,
 			signal: opts.signal
@@ -3342,7 +4736,7 @@ var Schedules = class {
 	}
 	/** `POST /v1/schedules/{id}/run` — run now (policy still applies). */
 	runNow(id, opts = {}) {
-		return this.http.json(one$1(id, "/run"), {
+		return this.http.json(one$2(id, "/run"), {
 			method: "POST",
 			body: {},
 			ext: opts.ext,
@@ -3353,7 +4747,7 @@ var Schedules = class {
 	}
 	/** `GET /v1/schedules/{id}/runs`. */
 	async runs(id, opts = {}) {
-		return [...(await this.http.json(one$1(id, "/runs"), {
+		return [...(await this.http.json(one$2(id, "/runs"), {
 			ext: opts.ext,
 			signal: opts.signal
 		})).runs];
@@ -3393,6 +4787,17 @@ var Schedules = class {
 			signal: opts.signal
 		});
 	}
+	/** `GET /v1/schedules/audit` — append-only scheduler history, newest first (optionally one schedule). */
+	async audit(params = {}, opts = {}) {
+		return [...(await this.http.json("/v1/schedules/audit", {
+			query: {
+				schedule_id: params.schedule_id,
+				limit: params.limit
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		})).audit];
+	}
 	/** `GET /v1/schedules/templates`. */
 	templates(opts = {}) {
 		return this.http.json("/v1/schedules/templates", {
@@ -3425,6 +4830,348 @@ var Schedules = class {
 	}
 };
 
+//#endregion
+//#region src/resources/lists.ts
+/** `/v1/lists/*`, `/v1/share` — lists and the share-sheet entry point. */
+const one$1 = (id, suffix = "") => `/v1/lists/${encodeURIComponent(id)}${suffix}`;
+const item = (id, suffix = "") => `/v1/lists/items/${encodeURIComponent(id)}${suffix}`;
+var Lists = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** `GET /v1/lists` — share-sheet order; presets are created on the first call. */
+	async list(params = {}, opts = {}) {
+		return [...(await this.http.json("/v1/lists", {
+			query: { archived: params.archived ? "1" : void 0 },
+			ext: opts.ext,
+			signal: opts.signal
+		})).lists];
+	}
+	/** `POST /v1/lists` — a custom list. */
+	async create(body, opts = {}) {
+		return (await this.http.json("/v1/lists", {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			acceptStatus: [201]
+		})).list;
+	}
+	/** `PATCH /v1/lists/order` — the order of your lists (and of the share-sheet targets). */
+	reorder(ids, opts = {}) {
+		return this.http.json("/v1/lists/order", {
+			method: "PATCH",
+			body: { ids },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `GET /v1/lists/stream` — live `list` events (keepalives skipped). */
+	async *stream(opts = {}) {
+		for await (const frame of this.http.sse("/v1/lists/stream", {
+			ext: opts.ext,
+			signal: opts.signal
+		})) {
+			if (frame.event !== "list") continue;
+			const data = frameJson(frame);
+			if (data) yield data;
+		}
+	}
+	/** `PATCH /v1/lists/{id}` — name, icon, color, share-sheet visibility, price watch, archived. */
+	async update(id, patch, opts = {}) {
+		return (await this.http.json(one$1(id), {
+			method: "PATCH",
+			body: patch,
+			ext: opts.ext,
+			signal: opts.signal
+		})).list;
+	}
+	/** `DELETE /v1/lists/{id}` — custom lists only (presets → 409 `preset_list`). */
+	async delete(id, opts = {}) {
+		await this.http.request(one$1(id), {
+			method: "DELETE",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `GET /v1/lists/{id}/items` — pinned first, then newest; done items only with `done: true`. */
+	async items(id, params = {}, opts = {}) {
+		return [...(await this.http.json(one$1(id, "/items"), {
+			query: {
+				done: params.done ? "1" : void 0,
+				limit: params.limit
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		})).items];
+	}
+	/** `POST /v1/lists/{id}/items` — 201 created, or 200 with the existing item (`created: false`). */
+	add(id, body, opts = {}) {
+		return this.http.json(one$1(id, "/items"), {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			acceptStatus: [200, 201]
+		});
+	}
+	/** `PATCH /v1/lists/items/{itemId}` — title, body, done, pinned, reminder; `list_id` moves it. */
+	async updateItem(itemId, patch, opts = {}) {
+		return (await this.http.json(item(itemId), {
+			method: "PATCH",
+			body: patch,
+			ext: opts.ext,
+			signal: opts.signal
+		})).item;
+	}
+	/** `DELETE /v1/lists/items/{itemId}` — also deletes its uploaded media. */
+	async deleteItem(itemId, opts = {}) {
+		await this.http.request(item(itemId), {
+			method: "DELETE",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `GET /v1/lists/items/{itemId}/image` — the uploaded image or the unfurled preview image. */
+	async image(itemId, opts = {}) {
+		const res = await this.http.request(item(itemId, "/image"), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+		return {
+			bytes: new Uint8Array(await res.arrayBuffer()),
+			contentType: res.headers.get("content-type") ?? "application/octet-stream"
+		};
+	}
+	/** `GET /v1/lists/{id}/export.md` — the whole list as GitHub-flavoured Markdown. */
+	async exportMarkdown(id, opts = {}) {
+		return (await this.http.request(one$1(id, "/export.md"), {
+			ext: opts.ext,
+			signal: opts.signal
+		})).text();
+	}
+	/** `POST /v1/share` — share-sheet entry point (`list_id`, `preset`, or auto → Inbox + suggestion). */
+	share(body, opts = {}) {
+		return this.http.json("/v1/share", {
+			method: "POST",
+			body,
+			ext: opts.ext,
+			signal: opts.signal,
+			acceptStatus: [200, 201]
+		});
+	}
+};
+
+//#endregion
+//#region src/resources/memory.ts
+var Memory = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** `GET /v1/memory` — newest first; `limit` 1–100 (20), optional `tier`. Not metered. */
+	list(query = {}, opts = {}) {
+		return this.http.json("/v1/memory", {
+			query: {
+				tier: query.tier,
+				limit: query.limit,
+				offset: query.offset
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `GET /v1/memory/search` — semantic recall, most relevant first; `limit` 1–10 (5). One embedding. */
+	search(query, opts = {}) {
+		return this.http.json("/v1/memory/search", {
+			query: {
+				q: query.q,
+				limit: query.limit
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `POST /v1/memory` — store one semantic memory (`content` ≤ 4000 chars, `importance` 0–1, default 0.6). */
+	create(input, opts = {}) {
+		return this.http.json("/v1/memory", {
+			method: "POST",
+			body: input,
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `DELETE /v1/memory/{id}` — 404 when the id is unknown or not yours. */
+	delete(id, opts = {}) {
+		return this.http.json(`/v1/memory/${encodeURIComponent(id)}`, {
+			method: "DELETE",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+};
+
+//#endregion
+//#region src/resources/sandboxes.ts
+/**
+* `/v1/sandboxes` — agent sandboxes (beta): isolated gVisor containers with a persistent
+* `/workspace`, no network by default, artifacts from `/workspace/out` as scanned, signed links.
+*/
+const base = (id) => `/v1/sandboxes/${encodeURIComponent(id)}`;
+/** Encode each segment of a workspace path, keeping the slashes. */
+const filePath = (p) => p.replace(/^\/+/, "").split("/").map((s) => encodeURIComponent(s)).join("/");
+const idem = (key) => key ? { "Idempotency-Key": key } : void 0;
+var SandboxFiles = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	/** `PUT /v1/sandboxes/{id}/files/{path}` — write raw bytes (≤ 100 MB) to `/workspace/<path>`. */
+	put(id, path, content, opts = {}) {
+		const body = typeof content === "string" ? new TextEncoder().encode(content) : content;
+		return this.http.json(`${base(id)}/files/${filePath(path)}`, {
+			method: "PUT",
+			rawBody: body,
+			headers: { "Content-Type": "application/octet-stream" },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `GET /v1/sandboxes/{id}/files/{path}` — raw bytes of `/workspace/<path>` (`sha256` from `x-sha256`). */
+	async get(id, path, opts = {}) {
+		const res = await this.http.request(`${base(id)}/files/${filePath(path)}`, {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+		return {
+			bytes: new Uint8Array(await res.arrayBuffer()),
+			sha256: res.headers.get("x-sha256"),
+			contentType: res.headers.get("content-type")
+		};
+	}
+	/** `GET /v1/sandboxes/{id}/files?path=` — entries under a directory (default the workspace root). */
+	list(id, path, opts = {}) {
+		return this.http.json(`${base(id)}/files`, {
+			query: { path },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+};
+var Sandboxes = class {
+	http;
+	files;
+	constructor(http) {
+		this.http = http;
+		this.files = new SandboxFiles(http);
+	}
+	/** `POST /v1/sandboxes` — start a sandbox (`ttl_seconds` 60–86400, default 3600; `egress` none by default). */
+	create(input = {}, opts = {}) {
+		return this.http.json("/v1/sandboxes", {
+			method: "POST",
+			body: input,
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `GET /v1/sandboxes` — your sandboxes, newest first, optionally one `status`. */
+	list(query = {}, opts = {}) {
+		return this.http.json("/v1/sandboxes", {
+			query: { status: query.status },
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `GET /v1/sandboxes/{id}` */
+	retrieve(id, opts = {}) {
+		return this.http.json(base(id), {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* `POST /v1/sandboxes/{id}/exec` — run one command and wait for it (≤ 900 s). Use
+	* {@link execStream} to receive stdout / stderr as they are produced.
+	*/
+	exec(id, input, opts = {}) {
+		return this.http.json(`${base(id)}/exec`, {
+			method: "POST",
+			body: input,
+			headers: idem(opts.idempotencyKey),
+			timeoutMs: execTimeoutMs(input.timeout_seconds),
+			noRetry: !opts.idempotencyKey,
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* `POST /v1/sandboxes/{id}/exec` with `Accept: text/event-stream` — yields `start`, `stdout`,
+	* `stderr`, `truncated` and finally `exit` (or `error`) events.
+	*/
+	async *execStream(id, input, opts = {}) {
+		const frames = this.http.sse(`${base(id)}/exec`, {
+			method: "POST",
+			body: input,
+			headers: {
+				Accept: "text/event-stream",
+				...idem(opts.idempotencyKey)
+			},
+			ext: opts.ext,
+			signal: opts.signal
+		});
+		for await (const frame of frames) {
+			const data = frameJson(frame);
+			if (!data || typeof data !== "object" || !("type" in data)) continue;
+			yield data;
+			if (data.type === "exit" || data.type === "error") return;
+		}
+	}
+	/** `GET /v1/sandboxes/{id}/artifacts` — collect `/workspace/out` (scanned, signed 1 h links). */
+	artifacts(id, opts = {}) {
+		return this.http.json(`${base(id)}/artifacts`, {
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `POST /v1/sandboxes/{id}/snapshot` — store a compressed copy of the workspace. */
+	snapshot(id, input = {}, opts = {}) {
+		return this.http.json(`${base(id)}/snapshot`, {
+			method: "POST",
+			body: input,
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/** `DELETE /v1/sandboxes/{id}` — destroy the sandbox and its workspace (204). */
+	async delete(id, opts = {}) {
+		await this.http.request(base(id), {
+			method: "DELETE",
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+	/**
+	* `POST /v1/sandboxes/run` — one shot: create, write `inputs` under `/workspace/in`, run,
+	* collect artifacts, destroy. Pass `idempotencyKey` to make retries safe.
+	*/
+	run(input, opts = {}) {
+		return this.http.json("/v1/sandboxes/run", {
+			method: "POST",
+			body: input,
+			headers: idem(opts.idempotencyKey),
+			timeoutMs: execTimeoutMs(input.timeout_seconds),
+			noRetry: !opts.idempotencyKey,
+			ext: opts.ext,
+			signal: opts.signal
+		});
+	}
+};
+/** Client timeout for a blocking exec: the server limit plus a margin for restore and upload. */
+function execTimeoutMs(timeoutSeconds) {
+	return ((timeoutSeconds ?? 120) + 60) * 1e3;
+}
+
 //#endregion
 //#region src/resources/transcripts.ts
 /**
@@ -4008,6 +5755,9 @@ const OPERATION_METHODS = {
 	getVideo: "videos.retrieve",
 	createRender: "renders.create",
 	getRender: "renders.retrieve",
+	listRenders: "renders.list",
+	createTimeline: "renders.createTimeline",
+	regenerateRenderScene: "renders.regenerateScene",
 	listAssets: "assets.list",
 	getAsset: "assets.retrieve",
 	getAssetContent: "assets.contentUrl",
@@ -4019,12 +5769,91 @@ const OPERATION_METHODS = {
 	cardsGeocode: "cards.geocode",
 	cardsStaticMap: "cards.staticMap",
 	cardsFx: "cards.fx",
+	cardsRoute: "cards.route",
+	cardsTrack: "cards.track",
+	cardsEfactura: "cards.efactura",
 	cardsUnfurl: "cards.unfurl",
+	cardsProduct: "cards.product",
+	cardsRender: "cards.render",
 	createDocument: "documents.create",
 	retrieveDocument: "documents.retrieve",
 	createDocumentPreview: "documents.preview",
 	retrievePreview: "documents.retrievePreview",
 	createDocumentVideo: "documents.video",
+	listCreatives: "creatives.list",
+	createCreative: "creatives.create",
+	getCreative: "creatives.retrieve",
+	deleteCreative: "creatives.delete",
+	getCreativeOutline: "creatives.outline",
+	findCreativeNodes: "creatives.find",
+	getCreativeSubtree: "creatives.subtree",
+	applyCreativeOps: "creatives.edit",
+	listCreativeVersions: "creatives.versions",
+	revertCreative: "creatives.revert",
+	forkCreative: "creatives.fork",
+	lintCreative: "creatives.lint",
+	getCreativeCompiled: "creatives.compiled",
+	renderCreative: "creatives.render",
+	createCreativeFrame: "creatives.frame",
+	getCreativeFrameJob: "creatives.frameJob",
+	commentCreative: "creatives.comment",
+	createCreativeVariants: "creatives.variants",
+	listCreativeVariants: "creatives.listVariants",
+	pickCreativeVariant: "creatives.pickVariant",
+	extractBrandKit: "brandKits.extract",
+	listBrandKits: "brandKits.list",
+	getBrandKit: "brandKits.retrieve",
+	deleteBrandKit: "brandKits.delete",
+	createBrandKit: "brandKits.create",
+	updateBrandKit: "brandKits.update",
+	exportBrandKitDtcg: "brandKits.exportDtcg",
+	restyleCreative: "creatives.restyle",
+	captionCreative: "creatives.captions",
+	getCreativeCaptionsSrt: "creatives.captionsSrt",
+	getCreativeCaptionsVtt: "creatives.captionsVtt",
+	adaptCreative: "creatives.adapt",
+	fixCreativeLint: "creatives.lintFix",
+	getCreativeControls: "creatives.controls",
+	getCreativeLocales: "creatives.locales",
+	localizeCreative: "creatives.localize",
+	forkCreativeLocale: "creatives.forkLocale",
+	createCreativeShare: "creatives.createShare",
+	listCreativeShares: "creatives.listShares",
+	revokeCreativeShare: "creatives.revokeShare",
+	getCreativeReview: "creatives.review",
+	updateCreativeReview: "creatives.requestReview",
+	listCreativeReviewThreads: "creatives.reviewThreads",
+	createCreativeReviewThread: "creatives.createReviewThread",
+	replyCreativeReviewThread: "creatives.replyReviewThread",
+	resolveCreativeReviewThread: "creatives.resolveReviewThread",
+	reopenCreativeReviewThread: "creatives.reopenReviewThread",
+	deleteCreativeReviewComment: "creatives.deleteReviewComment",
+	remixStudioShare: "shares.remix",
+	getPublicStudioShare: "shares.get",
+	createPublicReviewThread: "shares.comment",
+	replyPublicReviewThread: "shares.reply",
+	resolvePublicReviewThread: "shares.resolve",
+	reopenPublicReviewThread: "shares.reopen",
+	decidePublicReview: "shares.decide",
+	createVoiceRevocation: "voiceRevocations.create",
+	createStudioAbuseReport: "abuseReports.create",
+	checkProvenance: "provenance.check",
+	createStudioBatch: "batches.create",
+	listStudioBatches: "batches.list",
+	getStudioBatch: "batches.get",
+	cancelStudioBatch: "batches.cancel",
+	retryStudioBatch: "batches.retry",
+	exportStudioBatchCsv: "batches.exportCsv",
+	zipStudioBatch: "batches.zip",
+	saveCreativeTemplate: "creatives.saveTemplate",
+	listCreativeTemplates: "templates.list",
+	getCreativeTemplate: "templates.retrieve",
+	deleteCreativeTemplate: "templates.delete",
+	exportCreativeFcpxml: "creatives.exportFcpxml",
+	exportCreativeLottie: "creatives.exportLottie",
+	getStudioExport: "exports.retrieve",
+	createCreativeFromDocument: "creatives.fromDocument",
+	buildCreative: "creatives.build",
 	createSystemOne: "systemOne.create",
 	createTranscription: "audio.transcribe",
 	createSpeech: "audio.speech",
@@ -4126,13 +5955,42 @@ const OPERATION_METHODS = {
 	resumeSchedules: "schedules.resume",
 	listScheduleTemplates: "schedules.templates",
 	renderScheduleTemplate: "schedules.renderTemplate",
+	listScheduleAudit: "schedules.audit",
 	listHeartbeats: "heartbeats.list",
 	createHeartbeat: "heartbeats.create",
 	updateHeartbeat: "heartbeats.update",
 	deleteHeartbeat: "heartbeats.delete",
+	listLists: "lists.list",
+	createList: "lists.create",
+	reorderLists: "lists.reorder",
+	streamLists: "lists.stream",
+	updateList: "lists.update",
+	deleteList: "lists.delete",
+	listListItems: "lists.items",
+	addListItem: "lists.add",
+	updateListItem: "lists.updateItem",
+	deleteListItem: "lists.deleteItem",
+	getListItemImage: "lists.image",
+	exportListMarkdown: "lists.exportMarkdown",
+	shareToList: "lists.share",
 	getUsage: "usage.get",
 	listKeys: "keys.list",
 	setKeyTags: "keys.setTags",
+	listMemories: "memory.list",
+	searchMemories: "memory.search",
+	createMemory: "memory.create",
+	deleteMemory: "memory.delete",
+	createSandbox: "sandboxes.create",
+	listSandboxes: "sandboxes.list",
+	getSandbox: "sandboxes.retrieve",
+	execSandbox: "sandboxes.exec",
+	putSandboxFile: "sandboxes.files.put",
+	getSandboxFile: "sandboxes.files.get",
+	listSandboxFiles: "sandboxes.files.list",
+	listSandboxArtifacts: "sandboxes.artifacts",
+	snapshotSandbox: "sandboxes.snapshot",
+	deleteSandbox: "sandboxes.delete",
+	runSandbox: "sandboxes.run",
 	createSession: "sessions.create",
 	listSessions: "sessions.list",
 	getSession: "sessions.get",
@@ -4191,6 +6049,12 @@ const OPERATION_METHODS = {
 	listEnvironmentTasks: "environments.tasks.list",
 	createEnvironmentTask: "environments.tasks.create",
 	getEnvironmentTask: "environments.tasks.get",
+	execEnvironment: "environments.exec",
+	listEnvironmentFiles: "environments.files.list",
+	getEnvironmentFile: "environments.files.get",
+	putEnvironmentFile: "environments.files.put",
+	startEnvironmentJob: "environments.jobs.start",
+	getEnvironmentJob: "environments.jobs.get",
 	getAgentOutputKey: "verify.agentOutputKey",
 	verifyAgentOutput: "verify.agentOutput",
 	listEnvironmentPorts: "environments.ports.list",
@@ -4201,6 +6065,9 @@ const OPERATION_METHODS = {
 	removeEnvironmentSecret: "environments.secrets.remove",
 	getAccount: "account.get",
 	patchAccount: "account.update",
+	getBilling: "billing.get",
+	listBillingInvoices: "billing.invoices",
+	getReferrals: "referrals.get",
 	getSettings: "settings.get",
 	patchSettings: "settings.update",
 	getReceipt: "receipt.get",
@@ -4215,7 +6082,8 @@ const STREAMING_OPERATIONS = /* @__PURE__ */ new Set([
 	"createSpeechStream",
 	"streamPrompts",
 	"streamTranscripts",
-	"streamSchedules"
+	"streamSchedules",
+	"streamLists"
 ]);
 /**
 * Same parity contract for the separate Resolve service
@@ -4226,6 +6094,7 @@ const RESOLVE_OPERATION_METHODS = {
 	resolveHealth: "resolve.health",
 	createResolveJob: "resolve.submit",
 	getResolveJob: "resolve.get",
+	listResolveJobs: "resolve.list",
 	acceptResolveJob: "resolve.accept",
 	getResolveAttestation: "resolve.attestation",
 	getResolveKeys: "resolve.keys",
@@ -4415,6 +6284,28 @@ var CodaiApps = class {
 *   client.sfx.search / .import (codai Studio CC0 sound-effects library, codai-sfx)
 *   client.documents.create / .retrieve / .preview / .retrievePreview / .video / .createPreviewAndWait / .videoAndWait
 *     (codai Studio decks / docs / sheets → PPTX / DOCX / XLSX, codai-docs; previews codai-docs-preview)
+*   client.creatives.create / .retrieve / .outline / .find / .subtree / .edit / .versions / .revert / .fork / .lint
+*     / .compiled / .render / .frame / .frameJob / .comment / .variants / .listVariants / .pickVariant
+*     / .saveTemplate / .exportFcpxml / .exportLottie / .downloadLottie / .fromDocument / .build / .restyle / .captions / .captionsSrt / .captionsVtt
+*     / .adapt / .lintFix / .controls / .locales / .localize / .forkLocale / .createShare / .listShares
+*     / .revokeShare / .review / .requestReview / .resetReview / .reviewThreads / .createReviewThread
+*     / .replyReviewThread / .resolveReviewThread / .reopenReviewThread / .deleteReviewComment / .delete
+*     (codai Studio editable creative documents, ops + version history + A/B variants; free but render, comment,
+*     variants and frames beyond the daily quota)
+*   client.brandKits.create / .update / .exportDtcg / .extract / .list / .retrieve / .delete (codai Studio brand
+*     kits as DTCG tokens, from a web page or a logo; extract is
+*     token-metered, the rest free; apply with creatives.create({ kind, brand_kit_id }))
+*   client.templates.list / .retrieve / .delete (codai Studio templates saved with creatives.saveTemplate; free;
+*     use with creatives.create({ kind, template, vars }))
+*   client.exports.retrieve / .wait (codai Studio FCPXML exports queued with creatives.exportFcpxml; only newly
+*     rendered seconds are billed; Lottie exports from creatives.exportLottie are free and ready at once)
+*   client.batches.create / .dryRun / .list / .get / .cancel / .retry / .exportCsv / .zip / .wait (codai Studio
+*     batches: one creative per CSV / sheet row; free, row translations and renders billed as usual)
+*   client.shares.get / .remix / .comment / .reply / .resolve / .reopen / .decide (codai Studio share links from the
+*     outside: read a shared creative, remix a view link, comment and decide through a review link; free)
+*   client.voiceRevocations.create (public takedown ticket for a voice cloned in codai Studio; no key needed)
+*   client.abuseReports.create (public DSA notice about a codai Studio share / review link; no key needed)
+*   client.provenance.check (public: which codai AI-provenance marks a file carries; no key needed)
 *   client.systemOne.create / .batch (typed decisions, codai-s1)
 *   client.realtime.connect (WebSocket live STT / voice; not an OpenAPI operation)
 *   client.agents.run + client.agents.runs.*    client.tools.search / .fetch
@@ -4422,11 +6313,15 @@ var CodaiApps = class {
 *   client.tasks.*                              client.sessions.* (events, controls, lease, shares, stream)
 *   client.devices.* / client.hosts.*           client.orgs.* / client.account / client.receipt
 *   client.settings.get / .update (account-level settings shared by every device)
+*   client.billing.get / .invoices / .watchBalance (READ-ONLY billing overview; never starts a payment)
+*   client.referrals.get / .redeem / .setConsent (referral stats + invitees; mutations via PATCH /v1/account)
 *   client.usage.get / client.keys.list / .setTags (own usage breakdown + API keys)
 *   client.projects.*                           client.environments.* (members, ports, secrets)
+*   client.sandboxes.create / .list / .retrieve / .exec / .execStream / .files.put / .files.get / .files.list
+*     / .artifacts / .snapshot / .delete / .run (agent sandboxes, beta: isolated gVisor workspaces, no network by default)
 *   client.verify.agentOutputKey / .agentOutput (EXPERIMENTAL HIDE-signed agent outputs)
 *   client.feedback / client.phoneModels
-*   client.resolve.* (verified bug fixes on https://resolve.codai.ro — resolve.yaml)
+*   client.resolve.* (verified bug fixes on https://resolve.codai.ro — resolve.yaml; .list / .iterate page your jobs)
 *
 * Top-level `chat()`, `chatStream()`, `embeddings()`, `models()`, `feedback()`,
 * `mintToken()` from 0.2.x are kept as thin aliases.
@@ -4455,6 +6350,24 @@ var Codai = class {
 	sfx;
 	/** codai Studio documents (`documents.create({ type: 'deck', spec })` → PPTX / DOCX / XLSX, codai-docs, free; previews + deck → MP4). */
 	documents;
+	/** codai Studio creatives (`creatives.create({ kind: 'video' })`, `.edit(id, { baseSeq, ops })`, `.render(id)`; editable documents with versions, free except renders). */
+	creatives;
+	/** codai Studio brand kits (`brandKits.extract({ url })` → palette + fonts + logo; apply with `creatives.create({ kind, brand_kit_id })`). */
+	brandKits;
+	/** codai Studio templates (`creatives.saveTemplate(id, { vars })` saves one; `templates.list()`; create with `creatives.create({ kind, template, vars })`). */
+	templates;
+	/** codai Studio FCPXML exports (`creatives.exportFcpxml(id)` queues one; `exports.wait(id)` polls until the zip is ready). */
+	exports;
+	/** codai Studio batches (`batches.create({ source: { template_id }, csv })` → one creative per row; `batches.wait(id)`). */
+	batches;
+	/** codai Studio share links from the outside (`shares.get(url)`, `shares.remix(url)`, `shares.comment(url, …)`). */
+	shares;
+	/** Public takedown tickets for voices cloned in codai Studio (`voiceRevocations.create({ email, … })`; no key needed). */
+	voiceRevocations;
+	/** Public abuse reports about codai Studio share / review links (`abuseReports.create({ share_token, … })`; no key needed). */
+	abuseReports;
+	/** Public AI-provenance checker (`provenance.check(file)` → C2PA / RIFF INFO / ID3 / MP4 / XMP marks; no key needed). */
+	provenance;
 	/** Typed decisions from codai-s1 (`systemOne.create({ state, questions })`). */
 	systemOne;
 	tokens;
@@ -4475,6 +6388,8 @@ var Codai = class {
 	prompts;
 	/** codai Scheduler — cron / natural-language schedules run on any of your hosts or in the cloud (`schedules.create`, `.executor.claim`). */
 	schedules;
+	/** Lists and the share sheet — save links, text and media to Inbox / Wishlist / Notes or your own lists (`lists.share`). */
+	lists;
 	/** Heartbeat monitors — dead-man switches for crons codai does not run (`heartbeats.create({ name, period_s })` → `ping_url`). */
 	heartbeats;
 	/** Transcripts — voice recordings → diarized transcripts + insights (feature-flagged per account). */
@@ -4483,17 +6398,25 @@ var Codai = class {
 	usage;
 	/** Your API keys (device attribution, tags). */
 	keys;
+	/** Your persistent memory — the same store as the MCP memory tools (`memory.list/search/create/delete`). */
+	memory;
 	sessions;
 	devices;
 	hosts;
 	orgs;
 	projects;
 	environments;
+	/** Agent sandboxes (beta) — isolated gVisor workspaces: `sandboxes.create/exec/execStream/files/artifacts/run`. */
+	sandboxes;
 	/** EXPERIMENTAL (HIDE, unaudited): verify signed agent outputs. Provenance only. */
 	verify;
 	account;
 	/** Account-level settings shared by every device (`settings.get()`, `settings.update(partial, { version })`). */
 	settings;
+	/** READ-ONLY billing: plan, wallet, invoices, `watchBalance` (pay via the returned links, never via the SDK). */
+	billing;
+	/** Referral stats and invitees; `redeem(code)` / `setConsent(bool)` go through `PATCH /v1/account`. */
+	referrals;
 	receipt;
 	feedback;
 	phoneModels;
@@ -4527,6 +6450,15 @@ var Codai = class {
 		this.assets = new Assets(http);
 		this.sfx = new Sfx(http);
 		this.documents = new Documents(http);
+		this.creatives = new Creatives(http);
+		this.brandKits = new BrandKits(http);
+		this.templates = new Templates(http);
+		this.exports = new Exports(http);
+		this.batches = new Batches(http);
+		this.shares = new Shares(http);
+		this.voiceRevocations = new VoiceRevocations(http);
+		this.abuseReports = new AbuseReports(http);
+		this.provenance = new Provenance(http);
 		this.systemOne = new SystemOne(http);
 		this.tokens = new Tokens(http);
 		this.realtime = new Realtime({
@@ -4542,19 +6474,24 @@ var Codai = class {
 		this.notifications = new Notifications(http);
 		this.prompts = new Prompts(http);
 		this.schedules = new Schedules(http);
+		this.lists = new Lists(http);
 		this.heartbeats = new Heartbeats(http);
 		this.transcripts = new Transcripts(http);
 		this.usage = new Usage(http);
 		this.keys = new Keys(http);
+		this.memory = new Memory(http);
 		this.sessions = new Sessions(http);
 		this.devices = new Devices(http);
 		this.hosts = new Hosts(http);
 		this.orgs = new Orgs(http);
 		this.projects = new Projects(http);
 		this.environments = new Environments(http);
+		this.sandboxes = new Sandboxes(http);
 		this.verify = new Verify(http);
 		this.account = new Account(http);
 		this.settings = new Settings(http);
+		this.billing = new Billing(http);
+		this.referrals = new Referrals(http);
 		this.receipt = new Receipts(http);
 		this.phoneModels = new PhoneModels(http);
 		this.resolve = new Resolve(new HttpClient({
@@ -4647,5 +6584,5 @@ function allKeys(obj) {
 }
 
 //#endregion
-export { Account, AgentRuns, Agents, Assets, Audio, Cards, Chat, ChatCompletions, Codai, Codai as default, CodaiApps, CodaiError, Devices, Documents, Embeddings, EnvironmentMembers, EnvironmentPorts, EnvironmentSecrets, EnvironmentTasks, Environments, Feedback, Health, Heartbeats, Hosts, HttpClient, Images, Keys, Messages, Models, Music, Notifications, OPERATION_METHODS, OrgMembers, Orgs, PhoneModels, Projects, Prompts, RESOLVE_ATTESTATION_PAYLOAD_TYPE, RESOLVE_OPERATION_METHODS, RESOLVE_TERMINAL_STATUSES, Realtime, RealtimeSession, Receipts, Renders, Resolve, ResolveError, ResolveInsufficientFundsError, Responses, STREAMING_OPERATIONS, ScheduleExecutor, SchedulerHosts, Schedules, SessionControls, SessionEvents, SessionLease, SessionShares, Sessions, Settings, Sfx, SystemOne, TUS_CHUNK_BYTES, Tasks, Tokens, Tools, Transcripts, Triggers, Usage, Verify, Videos, extensionHeaders, frameJson, isAssetDto, mergeToolCall, readSse, realtimeUrl, resolveAttestationStatement, settingsConflictCurrent, uploadIdFromLocation, verifyAttestationWithKeys, verifyResolveWebhook };
+export { AbuseReports, Account, AgentRuns, Agents, Assets, Audio, Batches, Billing, BrandKits, Cards, Chat, ChatCompletions, Codai, Codai as default, CodaiApps, CodaiError, Creatives, Devices, Documents, Embeddings, EnvironmentFiles, EnvironmentJobs, EnvironmentMembers, EnvironmentPorts, EnvironmentSecrets, EnvironmentTasks, Environments, Exports, Feedback, Health, Heartbeats, Hosts, HttpClient, Images, Keys, Lists, Memory, Messages, Models, Music, Notifications, OPERATION_METHODS, OrgMembers, Orgs, PROVENANCE_MAX_BYTES, PhoneModels, Projects, Prompts, Provenance, RESOLVE_ATTESTATION_PAYLOAD_TYPE, RESOLVE_OPERATION_METHODS, RESOLVE_TERMINAL_STATUSES, Realtime, RealtimeSession, Receipts, Referrals, Renders, Resolve, ResolveError, ResolveInsufficientFundsError, Responses, STREAMING_OPERATIONS, SandboxFiles, Sandboxes, ScheduleExecutor, SchedulerHosts, Schedules, SessionControls, SessionEvents, SessionLease, SessionShares, Sessions, Settings, Sfx, Shares, SystemOne, TUS_CHUNK_BYTES, Tasks, Templates, Tokens, Tools, Transcripts, Triggers, Usage, Verify, Videos, VoiceRevocations, extensionHeaders, frameJson, isAssetDto, mergeToolCall, readSse, realtimeUrl, resolveAttestationStatement, settingsConflictCurrent, shareTokenFrom, uploadIdFromLocation, verifyAttestationWithKeys, verifyResolveWebhook };
 //# sourceMappingURL=index.js.map