@elmohq/sdk 0.0.0-stage → 0.1.0

package/dist/tools-SwP0sK8H.mjs

@@ -0,0 +1,2458 @@
+//#region src/internal/core/backoff.ts
+function jitterShare(jitter) {
+	if (typeof jitter === "number") return Math.min(1, Math.max(0, jitter));
+	if (jitter === "equal") return .5;
+	return jitter === true || jitter === "full" ? 1 : 0;
+}
+function backoffDelay(retry, options = {}) {
+	const { delay = 500, jitter = true, maxDelay = 3e4, strategy = "exponential" } = options;
+	const growth = strategy === "constant" ? delay : delay && delay * 2 ** retry;
+	const capped = Math.min(growth, maxDelay);
+	const share = jitterShare(jitter);
+	return share ? capped * (1 - share) + Math.random() * capped * share : capped;
+}
+function exceedsMaxRetryAfter(delay, max) {
+	return delay !== void 0 && delay > (max ?? 6e4);
+}
+const TIMER_LIMIT = 2147483647;
+function sleep(ms, signal) {
+	if (signal?.aborted) return Promise.reject(signal.reason);
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, Math.min(ms, TIMER_LIMIT));
+		function onAbort() {
+			clearTimeout(timer);
+			reject(signal.reason);
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+const RETRY_AFTER_HEADERS = [
+	{
+		name: "retry-after-ms",
+		unit: "millisecond"
+	},
+	{ name: "retry-after" },
+	{ name: "x-ratelimit-reset-after" },
+	{
+		kind: "moment",
+		name: "x-ratelimit-reset"
+	},
+	{
+		kind: "moment",
+		name: "x-rate-limit-reset"
+	}
+];
+const ASCTIME = /^[a-z]{3} ([a-z]{3}) +(\d\d?) (\d\d:\d\d:\d\d) (\d{4})$/i;
+const MOMENT = /^(?:(\d{4})-(\d\d)-(\d\d)[t ]|(?:[a-z]+, ?)?(\d\d?)[ -]([a-z]{3})[ -](\d\d|\d{4}) )([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d|60)(?:\.(\d{1,3})\d*)?)? ?(?:z|gmt|utc?|([+-])([01]\d|2[0-3]):?([0-5]\d))$/i;
+const MONTHS = "janfebmaraprmayjunjulaugsepoctnovdec";
+function moment(value, now) {
+	const match = MOMENT.exec(value.replace(ASCTIME, "$2 $1 $4 $3 GMT"));
+	if (!match) return void 0;
+	const year = match[6] ?? match[1];
+	const day = +(match[4] ?? match[3]);
+	const month = match[2] ? +match[2] - 1 : MONTHS.indexOf(match[5].toLowerCase()) / 3;
+	let full = +year;
+	if (year.length < 3) {
+		const present = new Date(now).getUTCFullYear();
+		full += present - present % 100;
+		if (full > present + 50) full -= 100;
+	}
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(full, month, day);
+	if (!full || date.getUTCMonth() !== month || date.getUTCDate() !== day) return void 0;
+	const zone = (match[11] === "-" ? -1 : 1) * (+(match[12] ?? 0) * 60 + +(match[13] ?? 0));
+	const seconds = (+match[7] * 60 + +match[8] - zone) * 60 + +(match[9] ?? 0);
+	return date.getTime() + seconds * 1e3 + +(match[10] ?? "").padEnd(3, "0");
+}
+const NUMBER = /^[0-9]+(?:\.[0-9]+)?$/;
+function parseRetryAfter(value, header = { name: "retry-after" }, now = Date.now()) {
+	if (!value) return void 0;
+	if (NUMBER.test(value)) {
+		const number = Number(value);
+		const ms = header.unit === "millisecond" ? number : number * 1e3;
+		return Math.max(0, header.kind === "moment" ? ms - now : ms);
+	}
+	const date = moment(value, now);
+	if (date === void 0) return void 0;
+	return Math.max(0, date - now);
+}
+function retryAfterDelay(response, headers = RETRY_AFTER_HEADERS, now = Date.now()) {
+	const clock = moment(response.headers.get("date") ?? "", now) ?? now;
+	for (const header of headers) {
+		const delay = parseRetryAfter(response.headers.get(header.name), header, clock);
+		if (delay !== void 0) return delay;
+	}
+}
+//#endregion
+//#region src/internal/core/errors.ts
+/** The base of every error this SDK throws, including one from a call that never arrived. */
+var ElmoError = class extends Error {
+	/** The class's name. Compare it where `instanceof` fails, such as across two copies of this SDK. */
+	name = "ElmoError";
+};
+function refusedInput(held, rule, got) {
+	return new ElmoError(`${held} ${rule}, and got ${got}, so the request was not sent.`);
+}
+/** Thrown before the request goes out, when no credential satisfied the call. */
+var MissingCredentialError = class extends ElmoError {
+	name = "MissingCredentialError";
+	/** Credential options that would have satisfied the call. */
+	schemes;
+	constructor(message, schemes = []) {
+		super(message);
+		this.schemes = schemes;
+	}
+};
+function unsendable(held) {
+	return `${held} holds a line break or another character a header cannot carry, so the request was not sent.`;
+}
+/**
+* Thrown when the caller called the request off before the API answered.
+*
+* Not a {@link TransportError}, so code that retries or reports a failed
+* connection leaves a call the caller cancelled alone.
+*/
+var AbortError = class extends ElmoError {
+	constructor(cause) {
+		super("The request was called off before the API answered.", { cause });
+		this.name = "AbortError";
+	}
+};
+const TRANSPORT_MESSAGES = {
+	connect: "The request never reached the API.",
+	other: "The connection failed before the whole reply arrived.",
+	timeout: "The API did not answer in time."
+};
+/** Thrown when no whole answer arrived, so there is no reply to go on. */
+var TransportError = class extends ElmoError {
+	kind;
+	/**
+	* Whether the API can have acted on the request. After `'no'`, the call is
+	* safe to send again, whatever its method.
+	*/
+	reachedServer;
+	/** How far the request got. */
+	stage;
+	constructor(failure, cause, message) {
+		const unreached = failure === "connect";
+		const stated = typeof failure === "string" ? {
+			cause,
+			reachedServer: unreached ? "no" : "maybe",
+			stage: unreached ? "connect" : "receive"
+		} : failure;
+		const kind = typeof failure === "string" ? failure : failure.reachedServer === "no" ? "connect" : "other";
+		super(message ?? TRANSPORT_MESSAGES[kind], stated);
+		this.kind = kind;
+		this.name = "TransportError";
+		this.reachedServer = stated.reachedServer;
+		this.stage = stated.stage;
+	}
+};
+function calledOffWith(reason) {
+	return reason instanceof AbortError || reason instanceof TransportError ? reason : new AbortError(reason);
+}
+const TIMEOUT_CODES = ["ECONNABORTED", "ETIMEDOUT"];
+function codeOf(error) {
+	let current = error;
+	for (let depth = 0; current instanceof Error && depth < 5; depth++) {
+		const { code } = current;
+		if (typeof code === "string") return code;
+		current = current.cause;
+	}
+}
+const UNREACHED = {
+	EAI_AGAIN: "resolve",
+	ECONNREFUSED: "connect",
+	ENOTFOUND: "resolve",
+	UND_ERR_CONNECT_TIMEOUT: "connect"
+};
+function failureOf(error) {
+	const stated = error ?? {};
+	if (stated.reachedServer && stated.stage) return stated;
+	const stage = UNREACHED[codeOf(error) ?? ""];
+	return {
+		aborted: error instanceof Error && error.name === "AbortError",
+		cause: error,
+		reachedServer: stage ? "no" : "maybe",
+		stage: stage ?? "receive"
+	};
+}
+function classifyError(error) {
+	if (error instanceof TransportError) return error.kind;
+	const failure = failureOf(error);
+	if (failure.aborted) return "abort";
+	if (error instanceof Error && error.name === "TimeoutError") return "timeout";
+	if (failure.reachedServer === "no") return "connect";
+	return TIMEOUT_CODES.includes(codeOf(error) ?? "") ? "timeout" : "other";
+}
+const USERINFO_RE = /^([a-z][a-z\d+.-]*:\/\/)[^/?#@]*@/i;
+function safeAddress(url) {
+	return (url.split("?")[0] ?? "").replace(USERINFO_RE, "$1");
+}
+/**
+* Thrown when a call waited on the API for as long as it allowed, from sending
+* the request to the last byte of the reply.
+*
+* A reply with status 408 is an {@link APIError}, not one of these.
+*/
+var TimeoutError = class extends TransportError {
+	/** Milliseconds the call was allowed to wait on the API. */
+	timeoutMs;
+	constructor(timeout, cause, target) {
+		super("timeout", cause, timeout === void 0 ? TRANSPORT_MESSAGES.timeout : `${target ?? "The request"} timed out after ${timeout} ms waiting on the API. Pass a larger \`timeout\` with the call, or \`timeout: false\` to wait as long as it takes.`);
+		this.name = "TimeoutError";
+		this.timeoutMs = timeout;
+	}
+};
+const CODE_KEYS = [
+	"code",
+	"error_code",
+	"errorCode",
+	"error_type",
+	"errorType"
+];
+function statedCode(bag) {
+	for (const key of CODE_KEYS) {
+		const value = bag[key];
+		if (typeof value === "string" && value.trim()) return value.trim();
+		if (typeof value === "number") return value;
+	}
+}
+function describeCode(error) {
+	if (!error || typeof error !== "object") return void 0;
+	const body = error;
+	const direct = statedCode(body);
+	if (direct !== void 0) return direct;
+	for (const value of Object.values(body)) if (value && typeof value === "object" && !Array.isArray(value)) {
+		const nested = statedCode(value);
+		if (nested !== void 0) return nested;
+	}
+}
+const MAX_MESSAGE_BODY = 200;
+function oneLine(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+function shorten(text) {
+	const line = oneLine(text);
+	if (line.length <= MAX_MESSAGE_BODY) return line;
+	const cut = line.slice(0, MAX_MESSAGE_BODY);
+	const space = cut.lastIndexOf(" ");
+	return `${(space > MAX_MESSAGE_BODY / 2 ? cut.slice(0, space) : cut).trimEnd()}…`;
+}
+const MESSAGE_KEYS = [
+	"message",
+	"error_message",
+	"errorMessage",
+	"error",
+	"detail",
+	"title",
+	"description"
+];
+function statedMessage(bag) {
+	for (const key of MESSAGE_KEYS) {
+		const value = bag[key];
+		if (typeof value === "string" && value.trim()) return value.trim();
+	}
+}
+function describeStatedFailure(error) {
+	if (typeof error === "string") return shorten(error.trim()) || void 0;
+	if (!error || typeof error !== "object") return void 0;
+	const body = error;
+	const direct = statedMessage(body);
+	if (direct) return shorten(direct);
+	for (const value of Object.values(body)) if (value && typeof value === "object") {
+		const nested = statedMessage(value);
+		if (nested) return shorten(nested);
+	}
+	const json = JSON.stringify(error);
+	return json && json !== "{}" && json !== "[]" ? shorten(json) : void 0;
+}
+function isStructured(body) {
+	return typeof body === "object" && body !== null && !(body instanceof Blob);
+}
+const REQUEST_ID_FALLBACKS = ["x-correlation-id", "cf-ray"];
+const REQUEST_ID_NAME = /(?:^|-)request-?id$/;
+function requestIdOf(response) {
+	let named;
+	response.headers.forEach((value, name) => {
+		if (!named && value && REQUEST_ID_NAME.test(name)) named = value;
+	});
+	if (named) return named;
+	for (const header of REQUEST_ID_FALLBACKS) {
+		const value = response.headers.get(header);
+		if (value) return value;
+	}
+}
+/** A failure the API answered with, so there is a status and a reply to read. */
+var APIError = class extends ElmoError {
+	/**
+	* The decoded failure body. `undefined` where the reply carried none, or
+	* carried text such as a proxy's page, which is in {@link APIError.text}.
+	*/
+	body;
+	/** The API's own error code, read from the failure body. `undefined` where it carried none. */
+	code;
+	headers;
+	/** The request id to quote when reporting this failure. */
+	requestId;
+	/**
+	* The reply that carried this failure. Its body is already read, so take it
+	* from {@link APIError.body} or {@link APIError.text}.
+	*/
+	response;
+	/** Milliseconds the API asked to wait before trying again. */
+	retryAfterMs;
+	status;
+	/**
+	* The failure body where the API sent text rather than JSON, such as a
+	* proxy's page. The message holds only its start.
+	*/
+	text;
+	constructor(status, body, response, note) {
+		const reason = response.statusText ? `${status} ${response.statusText}` : `${status}`;
+		const requestId = requestIdOf(response);
+		const url = response.url ? ` for "${safeAddress(response.url)}"` : "";
+		const where = requestId ? `${url} (request id "${requestId}")` : url;
+		const said = describeStatedFailure(body);
+		const tail = note ? `. ${note}${said ? ` The API said: ${said}` : ""}` : said ? `: ${said}` : ".";
+		super(`The API answered ${reason}${where}${tail}`);
+		this.body = isStructured(body) ? body : void 0;
+		this.code = describeCode(body);
+		this.headers = response.headers;
+		this.name = "APIError";
+		this.requestId = requestId;
+		this.response = response;
+		this.retryAfterMs = retryAfterDelay(response);
+		this.status = status;
+		this.text = typeof body === "string" ? body : void 0;
+	}
+};
+var UnsupportedInteractionError = class extends ElmoError {
+	interaction;
+	transport;
+	constructor(transport, interaction) {
+		super(`Transport "${transport}" cannot send this call. It has no "${interaction}" method.`);
+		this.interaction = interaction;
+		this.name = "UnsupportedInteractionError";
+		this.transport = transport;
+	}
+};
+function unansweredError(error) {
+	if (error instanceof ElmoError) return error;
+	const kind = classifyError(error);
+	if (kind === "abort") return new AbortError(error);
+	if (kind === "timeout") return new TimeoutError(void 0, error);
+	return new TransportError(failureOf(error));
+}
+function unsendableHeader(name) {
+	return new ElmoError(unsendable(`Header \`${name}\``));
+}
+function unsendableAddress(address, problem, fix) {
+	return new ElmoError(`"${address}" ${problem}, so the request was not sent. ${fix}`);
+}
+/** A reply from the API that this SDK could not read, whatever its status. */
+var DecodeError = class extends ElmoError {
+	/** Where the value sat, or absent where the whole reply failed. */
+	at;
+	/** The request id to quote when reporting this failure. */
+	requestId;
+	/** The reply. Its body is already read. */
+	response;
+	/** The reply's status. `undefined` where there is no {@link DecodeError.response}. */
+	status;
+	/** What the API sent. The message holds only a short form of it. */
+	value;
+	constructor(message, options = {}) {
+		const requestId = options.response && requestIdOf(options.response);
+		super(requestId ? `${message} The request id is "${requestId}".` : message, { cause: options.cause });
+		this.at = options.at;
+		this.name = "DecodeError";
+		this.requestId = requestId;
+		this.response = options.response;
+		this.status = options.response?.status;
+		this.value = options.value;
+	}
+};
+function emptyPathParameter(name, url) {
+	return new ElmoError(`Path parameter \`${name}\` is empty. \`${url}\` cannot be sent without it.`);
+}
+function sent(value) {
+	if (value === void 0) return "nothing";
+	if (typeof value === "string") return `"${shorten(value)}"`;
+	if (value === null || typeof value !== "object") return shorten(String(value));
+	try {
+		return shorten(JSON.stringify(value) ?? String(value));
+	} catch {
+		return shorten(String(value));
+	}
+}
+function unreadableValue(at, value, cause, response) {
+	return new DecodeError(`Could not read ${at === void 0 ? "the reply" : `\`${at}\` from the reply`}: the API sent ${sent(value)}.`, {
+		at,
+		cause,
+		response,
+		value
+	});
+}
+//#endregion
+//#region src/internal/codec/registry.ts
+function charsetOf(contentType) {
+	return contentType?.match(/;\s*charset\s*=\s*"?([^";\s]+)/i)?.[1];
+}
+function decoderFor(label, fatal) {
+	try {
+		return new TextDecoder(label, { fatal });
+	} catch {
+		return new TextDecoder("utf-8", { fatal });
+	}
+}
+async function readText(raw, json = false) {
+	return decoderFor(json ? void 0 : charsetOf(raw.headers.get("content-type")), raw.ok).decode(await raw.arrayBuffer());
+}
+function essenceOf(mediaType) {
+	return mediaType.split(";", 1)[0].trim().toLowerCase();
+}
+function selectCodec(codecs, mediaType) {
+	if (!mediaType) return void 0;
+	const essence = essenceOf(mediaType);
+	const format = essence.replace(/\/.*\+/, "/");
+	return codecs.find((codec) => codec.mediaTypes.some((candidate) => [essence, format].includes(essenceOf(candidate))));
+}
+function encodeNamedBody(codecs, mediaType, options) {
+	if (options.body === void 0) return void 0;
+	if (options.bodySerializer) return {
+		contentType: mediaType,
+		payload: options.bodySerializer(options.body)
+	};
+	if (options.bodySerializer === null) return {
+		contentType: mediaType,
+		payload: options.body
+	};
+	const codec = selectCodec(codecs, mediaType);
+	if (!codec) return {
+		contentType: mediaType,
+		payload: options.body
+	};
+	return {
+		contentType: codec.contentType,
+		payload: codec.encode(options.body)
+	};
+}
+//#endregion
+//#region src/internal/core/text.ts
+function scalarText(value) {
+	return value instanceof Date ? value.toISOString() : void 0;
+}
+function toText(value) {
+	return typeof value === "string" ? value : scalarText(value) ?? String(value);
+}
+//#endregion
+//#region src/internal/core/metadata.ts
+function entriesOf(source) {
+	if (typeof source[Symbol.iterator] === "function") return source;
+	return Object.entries(source);
+}
+function metadataText(value) {
+	if (Array.isArray(value)) return value.map(toText).join(",");
+	if (typeof value !== "object" || value === null || scalarText(value) !== void 0) return toText(value);
+	const pairs = [];
+	for (const [key, item] of Object.entries(value)) if (item !== void 0 && item !== null) pairs.push(key, toText(item));
+	return pairs.join(",");
+}
+function mergeMetadata(...sources) {
+	const merged = {};
+	for (const source of sources) {
+		if (!source) continue;
+		const seen = /* @__PURE__ */ new Set();
+		for (const [key, value] of entriesOf(source)) {
+			const name = key.toLowerCase();
+			if (value === void 0) continue;
+			if (value === null) {
+				delete merged[name];
+				seen.add(name);
+				continue;
+			}
+			const text = metadataText(value);
+			const held = seen.has(name) ? merged[name] : void 0;
+			seen.add(name);
+			if (held === void 0) merged[name] = text;
+			else merged[name] = Array.isArray(held) ? [...held, text] : [held, text];
+		}
+	}
+	return merged;
+}
+const FIELD_VALUE = /^[\t\x20-\x7e\x80-\xff]*$/;
+function isFieldValue(value) {
+	return FIELD_VALUE.test(value);
+}
+function metadataPairs(meta) {
+	const pairs = [];
+	for (const [name, value] of Object.entries(meta)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) {
+			for (const item of value) pairs.push([name, item]);
+			continue;
+		}
+		pairs.push([name, value]);
+	}
+	return pairs;
+}
+function unsendableName(meta) {
+	for (const [name, value] of metadataPairs(meta)) if (!isFieldValue(value)) return name;
+}
+function metadataHeaders(meta) {
+	const headers = new Headers();
+	for (const [name, value] of metadataPairs(meta)) headers.append(name, value);
+	return headers;
+}
+function metadataValue(value) {
+	if (value === void 0) return void 0;
+	return Array.isArray(value) ? value.join(", ") : value;
+}
+//#endregion
+//#region src/internal/core/config.ts
+function foldRetry(sources, merged) {
+	if (!sources.some((source) => source?.["retry"] !== void 0)) return merged;
+	let retry;
+	for (const source of sources) {
+		const own = source?.["retry"];
+		const count = source?.["maxRetries"];
+		const counted = typeof count === "number" && Number.isFinite(count);
+		if (own === false) retry = false;
+		else if (own !== void 0 || counted) {
+			const rules = {
+				...typeof retry === "object" && retry,
+				...typeof own === "object" && own
+			};
+			if (counted && (typeof own !== "object" || !own || !("maxRetries" in own))) rules["maxRetries"] = count;
+			retry = rules;
+		}
+	}
+	merged["retry"] = retry;
+	delete merged["maxRetries"];
+	return merged;
+}
+const MERGED_LAYERS = ["path", "query"];
+function mergeLayers(sources, merged) {
+	for (const key of MERGED_LAYERS) {
+		const layers = sources.filter((source) => source?.[key]);
+		if (!layers.length) continue;
+		const layer = {};
+		for (const source of layers) for (const [name, value] of Object.entries(source[key])) if (value !== void 0) layer[name] = value;
+		merged[key] = layer;
+	}
+	return merged;
+}
+function merge(sources, keepAccessors) {
+	const merged = {};
+	for (const source of sources) {
+		if (!source) continue;
+		if (keepAccessors) {
+			for (const [key, held] of Object.entries(Object.getOwnPropertyDescriptors(source))) if (held.get || held.value !== void 0) Object.defineProperty(merged, key, held);
+		} else for (const key of Object.keys(source)) {
+			const value = source[key];
+			if (value !== void 0) merged[key] = value;
+		}
+	}
+	merged.headers = mergeMetadata(...sources.map((source) => source?.headers));
+	return foldRetry(sources, mergeLayers(sources, merged));
+}
+function mergeConfigs(...sources) {
+	return merge(sources, false);
+}
+function createConfig(overrides = {}) {
+	return mergeConfigs({
+		errors: "throw",
+		headers: {}
+	}, overrides);
+}
+function baseURLOf(options, fallback) {
+	return options.baseURL ?? fallback;
+}
+function mergeDefaults(...sources) {
+	return merge(sources, true);
+}
+//#endregion
+//#region src/internal/core/credentials.ts
+const LAYER_ALIASES = {
+	defaultHeaders: "headers",
+	defaultPath: "path",
+	defaultQuery: "query"
+};
+function applyAliases(config, aliases) {
+	let applied;
+	for (const [alias, canonical] of Object.entries(aliases ? {
+		...LAYER_ALIASES,
+		...aliases
+	} : LAYER_ALIASES)) {
+		if (!(alias in config)) continue;
+		applied ??= { ...config };
+		if (applied[canonical] === void 0) applied[canonical] = applied[alias];
+		delete applied[alias];
+	}
+	return applied ?? config;
+}
+function applyCredentials(config, credentials) {
+	if (!credentials) return config;
+	let applied;
+	for (const [name, spec] of Object.entries(credentials)) {
+		if (spec.option === false || config[name] !== void 0 || !(name in config)) continue;
+		applied ??= { ...config };
+		delete applied[name];
+	}
+	return applied ?? config;
+}
+//#endregion
+//#region src/internal/core/body.ts
+function discardBody(result) {
+	const { response } = result ?? {};
+	if (response && !response.bodyUsed) response.body?.cancel().catch(() => {});
+}
+function isStreamed(body) {
+	if (typeof body !== "object" || body === null) return false;
+	return typeof body.getReader === "function" || Symbol.asyncIterator in body;
+}
+function replyWith(body, response) {
+	const reply = new Response(body, {
+		headers: response.headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+	Object.defineProperty(reply, "redirected", { value: response.redirected });
+	Object.defineProperty(reply, "url", { value: response.url });
+	return reply;
+}
+async function bufferReply(response, signal) {
+	if (response.body === null) return response;
+	const reader = response.body.getReader();
+	function cancel() {
+		reader.cancel(signal?.reason).catch(() => {});
+	}
+	if (signal?.aborted) cancel();
+	signal?.addEventListener("abort", cancel, { once: true });
+	const parts = [];
+	try {
+		for (;;) {
+			const step = await reader.read();
+			if (step.done) break;
+			parts.push(step.value);
+		}
+	} finally {
+		signal?.removeEventListener("abort", cancel);
+	}
+	if (signal?.aborted) throw signal.reason;
+	return replyWith(new ReadableStream({ start(controller) {
+		for (const part of parts) controller.enqueue(part);
+		controller.close();
+	} }), response);
+}
+//#endregion
+//#region src/internal/core/features.ts
+var FeatureRunner = class {
+	features;
+	constructor(features = []) {
+		this.features = features;
+	}
+	async options(options, callable, ctx) {
+		for (const feature of this.features) await feature.onOptions?.(options, callable, ctx);
+	}
+	async prepare(request, ctx) {
+		for (const feature of this.features) await feature.onPrepare?.(request, ctx);
+	}
+	async request(request, ctx) {
+		for (const feature of this.features) await feature.onRequest?.(request, ctx);
+	}
+	send(core, ctx, hook = "onSend") {
+		let next = core;
+		for (let i = this.features.length - 1; i >= 0; i--) {
+			const feature = this.features[i];
+			if (!feature[hook]) continue;
+			const downstream = next;
+			next = (request) => feature[hook](request, downstream, ctx);
+		}
+		return next;
+	}
+	async result(result, request, ctx) {
+		let current = result;
+		for (let i = this.features.length - 1; i >= 0; i--) current = await this.features[i].onResult?.(current, request, ctx) ?? current;
+		return current;
+	}
+	async error(error, request, ctx) {
+		let current = error;
+		for (let i = this.features.length - 1; i >= 0; i--) current = await this.features[i].onError?.(current, request, ctx) ?? current;
+		return current;
+	}
+};
+//#endregion
+//#region src/internal/core/protocol.ts
+function onlyProtocol(protocols, _interaction) {
+	return Object.values(protocols)[0];
+}
+//#endregion
+//#region src/internal/core/dispatch.ts
+async function readReply$1(setup, sent, request, from) {
+	const { binding, ctx, runner } = sent;
+	try {
+		const raw = from ?? sent.result.response;
+		let result = request.options.unread || !raw ? sent.result : await binding.readResult(raw, request, setup.codecs);
+		result = await runner.result(result, request, ctx);
+		if (request.options.unread) return result.response;
+		const failure = binding.readError?.(result, request) ?? result.error;
+		if (request.options.raw) return failure === void 0 ? result : {
+			...result,
+			error: failure
+		};
+		if (failure !== void 0) {
+			if (request.options.errors !== "return" && !request.options.envelope) throw failure;
+			return {
+				data: void 0,
+				error: await runner.error(failure, request, ctx),
+				ok: false,
+				status: result.status
+			};
+		}
+		return request.options.errors === "return" || request.options.envelope ? {
+			data: result.data,
+			error: void 0,
+			ok: true,
+			status: result.status
+		} : result.data;
+	} catch (error) {
+		throw await runner.error(error, request, ctx);
+	}
+}
+function rejectUnsendable(transport, request) {
+	throw new UnsupportedInteractionError(transport.name, request.interaction);
+}
+function shellOf(request) {
+	if (request.options.unread) return request;
+	return {
+		...request,
+		options: {
+			...request.options,
+			unread: true
+		}
+	};
+}
+function transportFor(setup, named, fallback) {
+	if (named === void 0) return fallback;
+	if (typeof named !== "string") return named;
+	const found = setup.transports?.(named);
+	if (!found) throw new ElmoError(`This client carries no transport named "${named}".`);
+	return found;
+}
+async function sendRequest(setup, request) {
+	const protocol = onlyProtocol(setup.protocols, request.interaction);
+	const { binding } = protocol;
+	const transport = transportFor(setup, request.options["transport"], protocol.transport);
+	const runner = new FeatureRunner(setup.features);
+	const ctx = {
+		binding,
+		transport
+	};
+	const { unary } = transport;
+	if (request.interaction !== "unary" || !unary) rejectUnsendable(transport, request);
+	try {
+		if (!binding.readResult) throw new ElmoError(`The "${binding.name}" binding reads no reply, so it cannot answer this call.`);
+		const send = async (attempt) => {
+			await runner.request(attempt, ctx);
+			const unsendable = unsendableName(attempt.meta);
+			if (unsendable !== void 0) throw unsendableHeader(unsendable);
+			attempt.log?.sending();
+			let raw;
+			try {
+				raw = await unary.call(transport, attempt);
+				if (!request.options.unread) raw = await bufferReply(raw, attempt.signal);
+			} catch (error) {
+				throw unansweredError(error);
+			}
+			return binding.readResult(raw, shellOf(attempt), setup.codecs);
+		};
+		return {
+			binding,
+			ctx,
+			result: await runner.send(send, ctx)(request),
+			runner
+		};
+	} catch (error) {
+		throw await runner.error(error, request, ctx);
+	}
+}
+async function execute(setup, request) {
+	return readReply$1(setup, await sendRequest(setup, request), request);
+}
+function buildRequestWithoutCookies(setup, callable, resolved) {
+	const interaction = callable.interaction ?? "unary";
+	const { binding } = onlyProtocol(setup.protocols, interaction);
+	const encoded = encodeNamedBody(setup.codecs, callable.mediaType, resolved);
+	const meta = mergeMetadata(resolved.headers);
+	if (encoded?.contentType && meta["content-type"] === void 0) meta["content-type"] = encoded.contentType;
+	const accept = callable.accept ?? setup.accept ?? binding.accept;
+	if (accept && meta["accept"] === void 0) meta["accept"] = accept;
+	return {
+		address: binding.resolveAddress(callable, resolved),
+		body: encoded?.payload,
+		callable,
+		interaction,
+		meta,
+		options: resolved,
+		signal: resolved.signal
+	};
+}
+async function prepare(setup, callable, options = {}) {
+	const { binding, transport } = onlyProtocol(setup.protocols, callable.interaction);
+	const resolved = mergeConfigs(setup.defaults, applyCredentials(applyAliases(options, setup.aliases), setup.credentials));
+	const runner = new FeatureRunner(setup.features);
+	const ctx = {
+		binding,
+		transport
+	};
+	await runner.options(resolved, callable, ctx);
+	const request = buildRequestWithoutCookies(setup, callable, resolved);
+	await runner.prepare(request, ctx);
+	return request;
+}
+async function dispatch(setup, callable, options = {}) {
+	return execute(setup, await prepare(setup, callable, options));
+}
+async function exchange(setup, callable, options = {}) {
+	const request = await prepare(setup, callable, options);
+	const sent = await sendRequest(setup, request);
+	let read;
+	return {
+		read: (from) => read ??= readReply$1(setup, sent, request, from),
+		requestId: () => sent.result.response && requestIdOf(sent.result.response),
+		response: sent.result.response
+	};
+}
+function readEnv(name) {
+	const global = globalThis;
+	return (global.process?.env?.[name] ?? global.Deno?.env?.get?.(name))?.trim() || void 0;
+}
+function readable(credentials) {
+	return Object.keys(credentials).filter((name) => credentials[name].variable && credentials[name].option !== false);
+}
+function envDefaults(base, env = {}, credentials = {}) {
+	const reads = /* @__PURE__ */ new WeakMap();
+	const held = readable(credentials);
+	function resolve() {
+		const read = {};
+		for (const [option, variable] of Object.entries(env)) {
+			const value = readEnv(variable) ?? base[option];
+			if (value !== void 0) read[option] = value;
+		}
+		if (held.length) {
+			const tokens = {};
+			for (const name of held) tokens[name] = readEnv(credentials[name].variable);
+			Object.assign(read, tokens);
+			const environment = base.environment;
+			if (environment !== void 0) read.environment = environment;
+		}
+		return read;
+	}
+	function resolvedFor(holder) {
+		let read = reads.get(holder);
+		if (!read) {
+			read = resolve();
+			reads.set(holder, read);
+		}
+		return read;
+	}
+	const decided = [
+		...Object.keys(env),
+		...held,
+		...held.length ? ["environment"] : []
+	];
+	const defaults = { ...base };
+	for (const key of decided) Object.defineProperty(defaults, key, {
+		configurable: true,
+		enumerable: true,
+		get() {
+			return resolvedFor(this)[key];
+		}
+	});
+	return defaults;
+}
+//#endregion
+//#region src/internal/core/client.ts
+function clientOf(setup) {
+	return Object.defineProperty({
+		call(callable, options) {
+			return dispatch(setup, callable, options);
+		},
+		exchange(callable, options) {
+			return exchange(setup, callable, options);
+		},
+		prepare(callable, options = {}) {
+			return prepare(setup, callable, options);
+		},
+		resolveAddress(callable, options = {}) {
+			const { binding } = onlyProtocol(setup.protocols, callable.interaction);
+			return binding.resolveAddress(callable, mergeConfigs(setup.defaults, options));
+		}
+	}, "setup", { value: setup });
+}
+function createClient(setup) {
+	return clientOf({
+		...setup,
+		defaults: envDefaults(setup.defaults, setup.env, setup.credentials)
+	});
+}
+function clientFor(args, fallback) {
+	const { client, key: _key, ...args_ } = args ?? {};
+	const base = client ?? fallback;
+	if (!base) throw new ElmoError("This SDK has no client of its own. Pass one as `client`.");
+	const config = applyCredentials(applyAliases(args_, base.setup.aliases), base.setup.credentials);
+	if (client && !Object.keys(config).length) return client;
+	const defaults = mergeDefaults(base.setup.defaults, config);
+	base.setup.guard?.(defaults);
+	return clientOf({
+		...base.setup,
+		defaults
+	});
+}
+function withClient(source, client, key = "client") {
+	const derived = Object.create(Object.getPrototypeOf(source));
+	derived[key] = client;
+	return derived;
+}
+//#endregion
+//#region src/internal/core/read-reply.ts
+async function readReply(read, value, _response) {
+	return await read(value);
+}
+//#endregion
+//#region src/internal/feature/validate.ts
+async function runValidator(validate, value, options, response) {
+	if (!validate || options["validate"] === false) return value;
+	return await readReply(validate, value, response);
+}
+function validatorsOf(callable) {
+	return callable.validators;
+}
+function validateFeature() {
+	return {
+		name: "validate",
+		async onOptions(options, callable) {
+			const validate = validatorsOf(callable)?.request;
+			if (!validate || options["validate"] === false) return;
+			Object.assign(options, await validate(options));
+		},
+		async onResult(result, request) {
+			const validators = validatorsOf(request.callable);
+			if (!validators) return result;
+			if (result.error !== void 0 && result.error !== null) result.error = await runValidator(validators.error, result.error, request.options, result.response);
+			else if (result.data !== void 0) result.data = await runValidator(validators.response, result.data, request.options, result.response);
+			return result;
+		}
+	};
+}
+function decoded(at, value, read) {
+	let result;
+	try {
+		result = read(value);
+	} catch (cause) {
+		throw unreadableValue(at, value, cause);
+	}
+	if (result instanceof Date && Number.isNaN(result.getTime())) throw unreadableValue(at, value);
+	return result;
+}
+function reviving(revive) {
+	return (data) => {
+		if (data != null) revive(data);
+		return data;
+	};
+}
+//#endregion
+//#region src/resources/shared/auth.ts
+/**
+* An instance admin key from `ADMIN_API_KEYS`, or an organization key (`elmo_…`) issued from the
+* dashboard.
+*/
+const apiKeyRequirements = [{
+	key: "apiKey",
+	scheme: "bearer",
+	type: "http"
+}];
+//#endregion
+//#region src/resources/shared/resource.ts
+var ElmoResource = class {
+	/** The client every call on this SDK dispatches through. */
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	/**
+	* The same calls, with different options.
+	*
+	* Options given here layer over the ones already in force. Headers, path
+	* parameters and query parameters merge per name. Everything else replaces.
+	* What this was called on does not change.
+	*/
+	withOptions(options) {
+		return withClient(this, clientFor(options, this.client));
+	}
+};
+//#endregion
+//#region src/internal/core/lazy-promise.ts
+var LazyPromise = class extends Promise {
+	answer;
+	constructor() {
+		super(() => {});
+	}
+	answered() {
+		return this.answer ??= this.settle();
+	}
+	then(onFulfilled, onRejected) {
+		return this.answered().then(onFulfilled, onRejected);
+	}
+	catch(onRejected) {
+		return this.answered().catch(onRejected);
+	}
+	finally(onFinally) {
+		return this.answered().finally(onFinally);
+	}
+	static get [Symbol.species]() {
+		return Promise;
+	}
+};
+function unattended(promise) {
+	promise.catch(() => {});
+	return promise;
+}
+//#endregion
+//#region src/internal/core/call-promise.ts
+function awaitedResult(client, options, result) {
+	if ((options.errors ?? client.setup.defaults.errors) === "return") return result;
+	if (result.ok === false) throw result.error;
+	return result.data;
+}
+/** A call already sent, whose reply is not yet read. */
+var CallPromise = class extends LazyPromise {
+	client;
+	exchange;
+	options;
+	envelope;
+	constructor(client, callable, options = {}) {
+		super();
+		this.client = client;
+		this.options = options;
+		this.exchange = unattended(client.exchange(callable, {
+			...options,
+			envelope: true
+		}));
+	}
+	/**
+	* The whole result envelope. A failure of the call is returned on it, not
+	* thrown. What one of your own functions throws, such as a hook, is thrown
+	* as it is.
+	*/
+	result() {
+		return this.envelope ??= this.read();
+	}
+	/** The payload alone, with a failure thrown rather than handed back. */
+	async unwrap() {
+		const result = await this.result();
+		if (result.ok === false) throw result.error;
+		return result.data;
+	}
+	async read() {
+		try {
+			return await this.decode();
+		} catch (error) {
+			if (!(error instanceof ElmoError)) throw error;
+			return {
+				error,
+				ok: false
+			};
+		}
+	}
+	settle() {
+		return this.result().then((result) => awaitedResult(this.client, this.options, result));
+	}
+	async decode() {
+		return (await this.exchange).read();
+	}
+};
+/** A call already sent, whose `Response` can be read as well as its payload. */
+var RestCallPromise = class extends CallPromise {
+	claimed = false;
+	unread;
+	/**
+	* The `Response` itself, with its body unread and yours to read once. An
+	* error status does not throw here. A call that got no response does.
+	*/
+	asResponse() {
+		return this.unread ??= this.claim();
+	}
+	/** The decoded body, the `Response` that carried it, and the request id. */
+	async withResponse() {
+		const data = await this;
+		const exchange = await this.exchange;
+		return {
+			data,
+			requestId: exchange.requestId(),
+			response: exchange.response
+		};
+	}
+	async decode() {
+		const exchange = await this.exchange;
+		const { response } = exchange;
+		if (!this.claimed || !response) return super.decode();
+		if (!response.bodyUsed) return exchange.read(response.clone());
+		throw new ElmoError("The body of this call was already read through asResponse(). Use withResponse() instead, which gives the body and the reply from one call.");
+	}
+	async claim() {
+		const { response } = await this.exchange;
+		if (!response) throw new ElmoError("This call was answered without a `Response`, so there is none to hand back.");
+		if (!response.bodyUsed) this.claimed = true;
+		return response;
+	}
+};
+function callPromise(client, callable, options = {}) {
+	return new RestCallPromise(client, callable, options);
+}
+//#endregion
+//#region src/internal/core/callable.ts
+function callable(descriptor) {
+	return {
+		interaction: "unary",
+		...descriptor
+	};
+}
+//#endregion
+//#region src/internal/core/params.ts
+const LAYERS = ["path", "query"];
+function mergeParams(inputs, options) {
+	const merged = {
+		...inputs,
+		...options
+	};
+	if (inputs && options) for (const layer of LAYERS) {
+		const declared = inputs[layer];
+		const given = options[layer];
+		if (!declared || !given) continue;
+		const both = { ...declared };
+		for (const [name, value] of Object.entries(given)) if (value !== void 0) both[name] = value;
+		merged[layer] = both;
+	}
+	return merged;
+}
+const placed = /* @__PURE__ */ new WeakMap();
+function placements(fields) {
+	let known = placed.get(fields);
+	if (!known) {
+		const built = /* @__PURE__ */ new Map();
+		for (const layer of Object.keys(fields)) {
+			const names = fields[layer];
+			if (typeof names === "string") built.set(names, {
+				in: layer,
+				map: names
+			});
+			else if (Array.isArray(names)) for (const key of names) built.set(key, {
+				in: layer,
+				map: key
+			});
+			else if (names) for (const [key, wire] of Object.entries(names)) built.set(key, {
+				in: layer,
+				map: wire
+			});
+		}
+		known = built;
+		placed.set(fields, built);
+	}
+	return known;
+}
+function placeParams(options, fields, extras) {
+	const named = placements(fields);
+	const grouped = {};
+	const given = {};
+	for (const [key, value] of Object.entries(options ?? {})) {
+		const place = named.get(key);
+		if (!place) {
+			if (extras === void 0) given[key] = value;
+			else (grouped[extras] ??= {})[key] = value;
+			continue;
+		}
+		if (place.in === "whole") {
+			grouped["body"] = value;
+			continue;
+		}
+		(grouped[place.in] ??= {})[place.map] = value;
+	}
+	return mergeParams(grouped, given);
+}
+function groupParams(options, layer) {
+	if (layer === void 0) return { ...options };
+	if (!options || !Object.keys(options).length) return {};
+	return { [layer]: { ...options } };
+}
+//#endregion
+//#region src/resources/analytics.ts
+const getBrandAnalyticsFields = { path: ["brandId"] };
+function reviveDateRange(value) {
+	if (value.start != null) value.start = decoded("DateRange.start", value.start, (raw) => new Date(raw));
+	if (value.end != null) value.end = decoded("DateRange.end", value.end, (raw) => new Date(raw));
+}
+function reviveBrandAnalytics(value) {
+	if (value.range != null) reviveDateRange(value.range);
+}
+const getBrandAnalyticsDescriptor = /* @__PURE__ */ callable({
+	address: "/brands/{brandId}/analytics",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveBrandAnalytics) }
+});
+const listBrandCitationDomainsFields = { path: ["brandId"] };
+function reviveCitationDomainList(value) {
+	if (value.range != null) reviveDateRange(value.range);
+}
+const listBrandCitationDomainsDescriptor = /* @__PURE__ */ callable({
+	address: "/brands/{brandId}/citations/domains",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveCitationDomainList) }
+});
+const listBrandCitationUrlsFields = { path: ["brandId"] };
+function reviveCitationUrlList(value) {
+	if (value.range != null) reviveDateRange(value.range);
+}
+const listBrandCitationURLsDescriptor = /* @__PURE__ */ callable({
+	address: "/brands/{brandId}/citations/urls",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveCitationUrlList) }
+});
+const listBrandPromptPerformanceFields = { path: ["brandId"] };
+function revivePromptPerformance(value) {
+	if (value.lastRunAt != null) value.lastRunAt = decoded("PromptPerformance.lastRunAt", value.lastRunAt, (raw) => new Date(raw));
+	if (value.firstEvaluatedAt != null) value.firstEvaluatedAt = decoded("PromptPerformance.firstEvaluatedAt", value.firstEvaluatedAt, (raw) => new Date(raw));
+}
+function revivePromptPerformanceList(value) {
+	if (value.range != null) reviveDateRange(value.range);
+	if (value.data != null) value.data.forEach((item) => {
+		revivePromptPerformance(item);
+	});
+}
+const listBrandPromptPerformanceDescriptor = /* @__PURE__ */ callable({
+	address: "/brands/{brandId}/prompt-performance",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(revivePromptPerformanceList) }
+});
+const getBrandQueryFanoutFields = { path: ["brandId"] };
+function reviveBrandQueryFanout(value) {
+	if (value.range != null) reviveDateRange(value.range);
+}
+const getBrandQueryFanoutDescriptor = /* @__PURE__ */ callable({
+	address: "/brands/{brandId}/query-fanout",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveBrandQueryFanout) }
+});
+/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+var Analytics = class extends ElmoResource {
+	/**
+	* Get a brand's analytics
+	*
+	* Visibility, share of voice, the per-model breakdown and the citation totals for one window, in
+	* one request.
+	*
+	* The long lists — cited domains and URLs, sub-queries, per-prompt results — are endpoints of
+	* their own. Everything else is always included.
+	*
+	* @param brandId Brand identifier.
+	*/
+	get(brandId, params, options) {
+		return callPromise(options?.client ?? this.client, getBrandAnalyticsDescriptor, mergeParams(placeParams({
+			...params,
+			brandId
+		}, getBrandAnalyticsFields, "query"), options));
+	}
+};
+/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+var Domains = class extends ElmoResource {
+	/**
+	* List cited domains
+	*
+	* Domains the engines cited when answering this brand's prompts, categorized and compared against
+	* the equal-length window immediately before this one.
+	*
+	* @param brandId Brand identifier.
+	*/
+	list(brandId, params, options) {
+		return callPromise(options?.client ?? this.client, listBrandCitationDomainsDescriptor, mergeParams(placeParams({
+			...params,
+			brandId
+		}, listBrandCitationDomainsFields, "query"), options));
+	}
+};
+/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+var URLs = class extends ElmoResource {
+	/**
+	* List cited URLs
+	*
+	* Individual pages the engines cited, with their category and page type.
+	*
+	* @param brandId Brand identifier.
+	*/
+	list(brandId, params, options) {
+		return callPromise(options?.client ?? this.client, listBrandCitationURLsDescriptor, mergeParams(placeParams({
+			...params,
+			brandId
+		}, listBrandCitationUrlsFields, "query"), options));
+	}
+};
+var Citations = class extends ElmoResource {
+	_domains;
+	/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+	get domains() {
+		return this._domains ??= new Domains(this.client);
+	}
+	_urls;
+	/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+	get urls() {
+		return this._urls ??= new URLs(this.client);
+	}
+};
+/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+var PromptPerformance = class extends ElmoResource {
+	/**
+	* List prompt performance
+	*
+	* Per-prompt mention rates over the window. The analytics counterpart to `GET /prompts?brandId=`,
+	* which returns prompt configuration rather than results.
+	*
+	* A prompt the brand stopped tracking is not sampled, so it has no results over the window and
+	* does not appear here.
+	*
+	* @param brandId Brand identifier.
+	*/
+	list(brandId, params, options) {
+		return callPromise(options?.client ?? this.client, listBrandPromptPerformanceDescriptor, mergeParams(placeParams({
+			...params,
+			brandId
+		}, listBrandPromptPerformanceFields, "query"), options));
+	}
+};
+/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+var QueryFanout = class extends ElmoResource {
+	/**
+	* Get query fan-out
+	*
+	* The searches engines ran while answering this brand's prompts. Engines that don't expose their
+	* searches still contribute runs, so `coverageRate` is the honest denominator.
+	*
+	* @param brandId Brand identifier.
+	*/
+	get(brandId, params, options) {
+		return callPromise(options?.client ?? this.client, getBrandQueryFanoutDescriptor, mergeParams(placeParams({
+			...params,
+			brandId
+		}, getBrandQueryFanoutFields, "query"), options));
+	}
+};
+//#endregion
+//#region src/resources/opportunities.ts
+const getBrandOpportunitiesFields = { path: ["brandId"] };
+function reviveBrandOpportunities(value) {
+	if (value.generatedAt != null) value.generatedAt = decoded("BrandOpportunities.generatedAt", value.generatedAt, (raw) => new Date(raw));
+}
+const getBrandOpportunitiesDescriptor = /* @__PURE__ */ callable({
+	address: "/brands/{brandId}/opportunities",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveBrandOpportunities) }
+});
+/** Where a brand could win more citations, and why */
+var Opportunities = class extends ElmoResource {
+	/**
+	* Get the latest opportunities report
+	*
+	* **Experimental — the response shape may still change.**
+	*
+	* The brand's Opportunities report: a prioritized set of ways to get cited more often, with the
+	* tracked prompts and cited pages behind each one. The same analysis the dashboard shows, from
+	* the same code.
+	*
+	* Generation is inline and synchronous. A stored report is served while it is fresh and
+	* regenerated when it is not, so there is nothing to poll for and no way to be handed a stale one
+	* — but a request that triggers a generation waits for it. The freshness window bounds the cost:
+	* however many callers ask, one generation per brand per window. There is deliberately no `POST`,
+	* which would spend provider budget with nothing metering it per call.
+	*
+	* @experimental
+	* @param brandId Brand identifier.
+	*/
+	get(brandId, options) {
+		return callPromise(options?.client ?? this.client, getBrandOpportunitiesDescriptor, mergeParams(placeParams({ brandId }, getBrandOpportunitiesFields, "query"), options));
+	}
+};
+//#endregion
+//#region src/resources/shared/rule.ts
+const nameRule = {
+	min: 1,
+	name: "name",
+	of: "characters"
+};
+const domainsRule = {
+	min: 1,
+	name: "domains",
+	of: "items"
+};
+const brandNameRule = {
+	min: 1,
+	name: "brandName",
+	of: "characters"
+};
+const valueRule = {
+	min: 1,
+	name: "value",
+	of: "characters"
+};
+//#endregion
+//#region src/resources/tags.ts
+const listBrandTagsFields = { path: ["brandId"] };
+const listBrandTagsDescriptor = /* @__PURE__ */ callable({
+	address: "/brands/{brandId}/tags",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json"
+});
+/** The tags in use on a brand's prompts */
+var Tags = class extends ElmoResource {
+	/**
+	* List a brand's tags
+	*
+	* Every tag in use on the brand's prompts, with how many carry each — enough to build the same
+	* filter the dashboard shows without paging the whole prompt list to derive it.
+	*
+	* Tags are not a resource of their own: a tag exists exactly as long as some prompt carries it.
+	* `branded` and `unbranded` are computed by Elmo and always listed.
+	*
+	* @param brandId Brand identifier.
+	*/
+	list(brandId, options) {
+		return callPromise(options?.client ?? this.client, listBrandTagsDescriptor, mergeParams(placeParams({ brandId }, listBrandTagsFields, "query"), options));
+	}
+};
+//#endregion
+//#region src/internal/page/page.ts
+function readPath(value, path) {
+	if (!path) return value;
+	let current = value;
+	for (const key of path.split(".")) {
+		if (current === null || typeof current !== "object") return void 0;
+		current = current[key];
+	}
+	return current;
+}
+function readItems(data, pagination) {
+	const items = readPath(data, pagination.items);
+	return Array.isArray(items) ? items : [];
+}
+function withPosition(options, pagination, value) {
+	const name = pagination.param;
+	if (!name) return options;
+	if ((pagination.in ?? "query") === "body") return {
+		...options,
+		body: {
+			...options.body,
+			[name]: value
+		}
+	};
+	return {
+		...options,
+		query: {
+			...options.query,
+			[name]: value
+		}
+	};
+}
+function resumeAt(walk, pagination, param) {
+	if (pagination.style === "link") {
+		const options = { ...walk.options };
+		delete options.query;
+		return {
+			...walk,
+			descriptor: {
+				...walk.descriptor,
+				address: param
+			},
+			options
+		};
+	}
+	const options = withPosition(walk.options, pagination, param);
+	if (pagination.style === "cursor") return {
+		...walk,
+		cursor: param,
+		options
+	};
+	return {
+		...walk,
+		options,
+		position: param
+	};
+}
+function readCount(data, path) {
+	if (!path) return void 0;
+	const value = readPath(data, path);
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
+	return value;
+}
+function startOf(pagination) {
+	return pagination.start ?? (pagination.style === "page" ? 1 : 0);
+}
+function stepCounted(walk, pagination, result, count, limit) {
+	if (!count) return void 0;
+	const size = readCount(result.data, pagination.size) ?? limit;
+	const position = walk.position + (pagination.style === "page" ? 1 : size || count);
+	const start = startOf(pagination);
+	const pages = pagination.style === "page" ? readCount(result.data, pagination.pages) : void 0;
+	const total = readCount(result.data, pagination.total);
+	if (pages === void 0 && total === void 0 && size !== void 0 && count < size) return;
+	if (pages !== void 0 && position - start >= pages) return void 0;
+	if (total !== void 0) {
+		if ((pagination.style === "page" ? (position - start) * (size ?? count) : position) >= total) return void 0;
+	}
+	return position;
+}
+const STEPPERS = { page: stepCounted };
+const SCHEME_RE = /^[a-z][a-z\d+.-]*:/i;
+function pageURL(address) {
+	if (typeof address !== "string") return void 0;
+	try {
+		const url = new URL(address, globalThis.location?.href);
+		return url.origin === "null" ? void 0 : url;
+	} catch {
+		return;
+	}
+}
+function followLink(client, walk, link) {
+	const own = pageURL(client.resolveAddress(walk.descriptor, walk.options));
+	if (!own) {
+		if (!SCHEME_RE.test(link) && !link.startsWith("//")) return link;
+		throw new ElmoError("Pagination stopped: the next page names a host, and no base URL says which host this client sends its credentials to.");
+	}
+	const target = new URL(link, own);
+	if (target.origin !== own.origin) throw new ElmoError(`Pagination stopped: the next page is on ${target.origin}, and this client sends its credentials only to ${own.origin}.`);
+	return SCHEME_RE.test(link) ? link : target.href;
+}
+function saysMore(data, pagination) {
+	return !pagination.more || readPath(data, pagination.more) !== false;
+}
+function stepWalk(client, walk, pagination, result, count, limit) {
+	const step = STEPPERS[pagination.style];
+	if (!step) throw new ElmoError(`Cannot walk "${walk.descriptor.address}": this client does not page by "${pagination.style}".`);
+	if (!saysMore(result.data, pagination)) return void 0;
+	const next = step(walk, pagination, result, count, limit);
+	return pagination.style === "link" && next !== void 0 ? followLink(client, walk, next) : next;
+}
+async function* walkFrom(page, maxPages) {
+	let current = page;
+	for (let index = 1;; index++) {
+		for (const item of current.data) yield item;
+		if (index >= maxPages || !current.hasNextPage()) return;
+		current = await current.getNextPage();
+	}
+}
+async function loadPage(client, walk, pagination, limit, maxPages) {
+	const result = await client.call(walk.descriptor, walk.options);
+	if (result.error !== void 0) throw result.error;
+	const data = readItems(result.data, pagination);
+	const param = stepWalk(client, walk, pagination, result, data.length, limit);
+	const page = {
+		[Symbol.asyncIterator]: () => walkFrom(page, maxPages),
+		body: result.data,
+		data,
+		getNextPage: () => {
+			if (param === void 0) return Promise.reject(new ElmoError(`"${walk.descriptor.address}" has no page after this one. Check \`hasNextPage()\` first.`));
+			return loadPage(client, resumeAt(walk, pagination, param), pagination, limit, maxPages);
+		},
+		hasNextPage: () => param !== void 0,
+		nextPageParam: param,
+		status: result.status
+	};
+	return page;
+}
+function maxPagesFor(client, options) {
+	return options["maxPages"] ?? client.setup.defaults["maxPages"] ?? 1e3;
+}
+function openedAt(options, pagination) {
+	if (!pagination.param) return void 0;
+	return options[pagination.in ?? "query"]?.[pagination.param];
+}
+function paginationOf(callable) {
+	if (callable.pagination) return callable.pagination;
+	throw new ElmoError(`"${callable.address}" is not a paged call, so it has no pages to walk.`);
+}
+function openWalk(callable, options) {
+	const pagination = paginationOf(callable);
+	const opened = openedAt(options, pagination);
+	return {
+		cursor: pagination.style === "cursor" ? opened : void 0,
+		descriptor: callable,
+		options: {
+			...options,
+			raw: true
+		},
+		position: typeof opened === "number" && Number.isFinite(opened) ? opened : startOf(pagination)
+	};
+}
+function pageStream(load, maxPages) {
+	return { async *[Symbol.asyncIterator]() {
+		let current = await load();
+		for (let index = 1;; index++) {
+			yield current;
+			if (index >= maxPages || !current.hasNextPage()) return;
+			current = await current.getNextPage();
+		}
+	} };
+}
+function requestedLimit(options, pagination) {
+	if (!pagination.limitParam) return void 0;
+	const layer = options[pagination.in ?? "query"];
+	const limit = Number(layer?.[pagination.limitParam]);
+	return Number.isFinite(limit) && limit > 0 ? limit : void 0;
+}
+/**
+* A paginated call. Awaiting it gives the first page, or its result envelope
+* under the `'return'` error mode. Iterating it gives every item on every page,
+* and throws on a failed page under either mode.
+*/
+var PagePromise = class extends LazyPromise {
+	envelope;
+	callable;
+	client;
+	limit;
+	maxPages;
+	options;
+	pagination;
+	project;
+	first;
+	constructor(client, callable, options, project) {
+		super();
+		this.callable = callable;
+		this.client = client;
+		this.options = options;
+		this.pagination = paginationOf(callable);
+		this.limit = requestedLimit(options, this.pagination);
+		this.maxPages = maxPagesFor(client, options);
+		this.project = project;
+		const opened = openWalk(this.callable, this.options);
+		const param = options["pageParam"];
+		this.first = unattended(loadPage(this.client, param === void 0 ? opened : resumeAt(opened, this.pagination, param), this.pagination, this.limit, this.maxPages));
+	}
+	/** Every item, page after page, up to `maxPages`. */
+	async *[Symbol.asyncIterator]() {
+		yield* walkFrom(await this.first, this.maxPages);
+	}
+	/** Every page, up to `maxPages`. */
+	iterPages() {
+		return pageStream(() => this.first, this.maxPages);
+	}
+	/**
+	* The whole result envelope. A failure of the call is returned on it, not
+	* thrown. What one of your own functions throws, such as a hook, is thrown
+	* as it is.
+	*/
+	result() {
+		return this.envelope ??= this.read();
+	}
+	/** The page alone, with a failure thrown rather than handed back. */
+	async unwrap() {
+		const result = await this.result();
+		if (result.ok === false) throw result.error;
+		return result.data;
+	}
+	async read() {
+		try {
+			const page = await this.first;
+			return {
+				data: this.project(page),
+				ok: true,
+				status: page.status
+			};
+		} catch (error) {
+			if (!(error instanceof ElmoError)) throw error;
+			return {
+				error,
+				ok: false,
+				status: error instanceof APIError ? error.status : void 0
+			};
+		}
+	}
+	settle() {
+		return this.result().then((result) => awaitedResult(this.client, this.options, result));
+	}
+};
+function pages(client, callable, options = {}) {
+	return new PagePromise(client, callable, options, (page) => page);
+}
+//#endregion
+//#region src/resources/brands.ts
+function reviveBrand(value) {
+	if (value.createdAt != null) value.createdAt = decoded("Brand.createdAt", value.createdAt, (raw) => new Date(raw));
+	if (value.updatedAt != null) value.updatedAt = decoded("Brand.updatedAt", value.updatedAt, (raw) => new Date(raw));
+}
+function reviveBrandsList(value) {
+	if (value.data != null) value.data.forEach((item) => {
+		reviveBrand(item);
+	});
+	if (value.brands != null) value.brands.forEach((item) => {
+		reviveBrand(item);
+	});
+}
+const listBrandsDescriptor = /* @__PURE__ */ callable({
+	address: "/brands",
+	auth: apiKeyRequirements,
+	method: "get",
+	pagination: {
+		items: "data",
+		limitParam: "limit",
+		pages: "pagination.totalPages",
+		param: "page",
+		size: "pagination.limit",
+		style: "page",
+		total: "pagination.total"
+	},
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveBrandsList) }
+});
+const createBrandDescriptor = /* @__PURE__ */ callable({
+	address: "/brands",
+	auth: apiKeyRequirements,
+	mediaType: "application/json",
+	method: "post",
+	returns: "json",
+	rules: [
+		{
+			min: 1,
+			name: "id",
+			of: "characters"
+		},
+		nameRule,
+		domainsRule
+	],
+	validators: { response: /* @__PURE__ */ reviving(reviveBrand) }
+});
+const getBrandFields = { path: ["brandId"] };
+const getBrandDescriptor = /* @__PURE__ */ callable({
+	address: "/brands/{brandId}",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveBrand) }
+});
+const updateBrandFields = { path: ["brandId"] };
+const updateBrandDescriptor = /* @__PURE__ */ callable({
+	address: "/brands/{brandId}",
+	auth: apiKeyRequirements,
+	mediaType: "application/json",
+	method: "patch",
+	returns: "json",
+	rules: [brandNameRule, domainsRule],
+	validators: { response: /* @__PURE__ */ reviving(reviveBrand) }
+});
+/** Manage brand records */
+var Brands = class extends ElmoResource {
+	/** Create a brand */
+	create(params, options) {
+		return callPromise(options?.client ?? this.client, createBrandDescriptor, mergeParams(groupParams(params, "body"), options));
+	}
+	/**
+	* Get a brand
+	*
+	* @param brandId Brand identifier
+	*/
+	get(brandId, options) {
+		return callPromise(options?.client ?? this.client, getBrandDescriptor, mergeParams(placeParams({ brandId }, getBrandFields, "query"), options));
+	}
+	list(params, options) {
+		return pages(options?.client ?? this.client, listBrandsDescriptor, mergeParams(groupParams(params, "query"), options));
+	}
+	/**
+	* Update a brand
+	*
+	* @param brandId Brand identifier
+	*/
+	update(brandId, params, options) {
+		return callPromise(options?.client ?? this.client, updateBrandDescriptor, mergeParams(placeParams({
+			...params,
+			brandId
+		}, updateBrandFields, "body"), options));
+	}
+	_analytics;
+	/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+	get analytics() {
+		return this._analytics ??= new Analytics(this.client);
+	}
+	_citations;
+	get citations() {
+		return this._citations ??= new Citations(this.client);
+	}
+	_opportunities;
+	/** Where a brand could win more citations, and why */
+	get opportunities() {
+		return this._opportunities ??= new Opportunities(this.client);
+	}
+	_promptPerformance;
+	/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+	get promptPerformance() {
+		return this._promptPerformance ??= new PromptPerformance(this.client);
+	}
+	_queryFanout;
+	/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+	get queryFanout() {
+		return this._queryFanout ??= new QueryFanout(this.client);
+	}
+	_tags;
+	/** The tags in use on a brand's prompts */
+	get tags() {
+		return this._tags ??= new Tags(this.client);
+	}
+};
+//#endregion
+//#region src/resources/competitors.ts
+function reviveCompetitor(value) {
+	if (value.createdAt != null) value.createdAt = decoded("Competitor.createdAt", value.createdAt, (raw) => new Date(raw));
+	if (value.updatedAt != null) value.updatedAt = decoded("Competitor.updatedAt", value.updatedAt, (raw) => new Date(raw));
+}
+function reviveCompetitorsList(value) {
+	if (value.data != null) value.data.forEach((item) => {
+		reviveCompetitor(item);
+	});
+	if (value.competitors != null) value.competitors.forEach((item) => {
+		reviveCompetitor(item);
+	});
+}
+const listCompetitorsDescriptor = /* @__PURE__ */ callable({
+	address: "/competitors",
+	auth: apiKeyRequirements,
+	method: "get",
+	pagination: {
+		items: "data",
+		limitParam: "limit",
+		pages: "pagination.totalPages",
+		param: "page",
+		size: "pagination.limit",
+		style: "page",
+		total: "pagination.total"
+	},
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveCompetitorsList) }
+});
+const createCompetitorDescriptor = /* @__PURE__ */ callable({
+	address: "/competitors",
+	auth: apiKeyRequirements,
+	mediaType: "application/json",
+	method: "post",
+	returns: "json",
+	rules: [{
+		min: 1,
+		name: "brandId",
+		of: "characters"
+	}, nameRule],
+	validators: { response: /* @__PURE__ */ reviving(reviveCompetitor) }
+});
+const deleteCompetitorFields = { path: ["competitorId"] };
+const deleteCompetitorDescriptor = /* @__PURE__ */ callable({
+	address: "/competitors/{competitorId}",
+	auth: apiKeyRequirements,
+	method: "delete",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveCompetitor) }
+});
+const getCompetitorFields = { path: ["competitorId"] };
+const getCompetitorDescriptor = /* @__PURE__ */ callable({
+	address: "/competitors/{competitorId}",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveCompetitor) }
+});
+const updateCompetitorFields = { path: ["competitorId"] };
+const updateCompetitorDescriptor = /* @__PURE__ */ callable({
+	address: "/competitors/{competitorId}",
+	auth: apiKeyRequirements,
+	mediaType: "application/json",
+	method: "patch",
+	returns: "json",
+	rules: [nameRule],
+	validators: { response: /* @__PURE__ */ reviving(reviveCompetitor) }
+});
+/** Manage brand competitors */
+var Competitors = class extends ElmoResource {
+	/** Add a competitor */
+	create(params, options) {
+		return callPromise(options?.client ?? this.client, createCompetitorDescriptor, mergeParams(groupParams(params, "body"), options));
+	}
+	/**
+	* Delete a competitor
+	*
+	* @param competitorId Competitor identifier (UUID)
+	*/
+	delete(competitorId, options) {
+		return callPromise(options?.client ?? this.client, deleteCompetitorDescriptor, mergeParams(placeParams({ competitorId }, deleteCompetitorFields, "query"), options));
+	}
+	/**
+	* Get a competitor
+	*
+	* @param competitorId Competitor identifier (UUID)
+	*/
+	get(competitorId, options) {
+		return callPromise(options?.client ?? this.client, getCompetitorDescriptor, mergeParams(placeParams({ competitorId }, getCompetitorFields, "query"), options));
+	}
+	list(params, options) {
+		return pages(options?.client ?? this.client, listCompetitorsDescriptor, mergeParams(groupParams(params, "query"), options));
+	}
+	/**
+	* Update a competitor
+	*
+	* @param competitorId Competitor identifier (UUID)
+	*/
+	update(competitorId, params, options) {
+		return callPromise(options?.client ?? this.client, updateCompetitorDescriptor, mergeParams(placeParams({
+			...params,
+			competitorId
+		}, updateCompetitorFields, "body"), options));
+	}
+};
+//#endregion
+//#region src/resources/identity.ts
+function reviveApiKeyIdentity(value) {
+	if (value.createdAt != null) value.createdAt = decoded("ApiKeyIdentity.createdAt", value.createdAt, (raw) => new Date(raw));
+	if (value.expiresAt != null) value.expiresAt = decoded("ApiKeyIdentity.expiresAt", value.expiresAt, (raw) => new Date(raw));
+	if (value.lastUsedAt != null) value.lastUsedAt = decoded("ApiKeyIdentity.lastUsedAt", value.lastUsedAt, (raw) => new Date(raw));
+}
+const getMeDescriptor = /* @__PURE__ */ callable({
+	address: "/me",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveApiKeyIdentity) }
+});
+/** What the calling key is and what it may reach */
+var Me = class extends ElmoResource {
+	/**
+	* Describe the calling key
+	*
+	* What this key is, which organization and brands it reaches, and which scopes it holds. Requires
+	* no scope, so it is always safe to call first when wiring up an integration.
+	*/
+	get(options) {
+		return callPromise(options?.client ?? this.client, getMeDescriptor, options);
+	}
+};
+//#endregion
+//#region src/resources/models.ts
+const listModelsDescriptor = /* @__PURE__ */ callable({
+	address: "/models",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json"
+});
+/** The answer engines this deployment can track */
+var Models = class extends ElmoResource {
+	/**
+	* List trackable models
+	*
+	* The answer engines this deployment can track, so a client can build a model filter without
+	* hardcoding ids that differ between deployments.
+	*
+	* Requires no scope.
+	*/
+	list(options) {
+		return callPromise(options?.client ?? this.client, listModelsDescriptor, options);
+	}
+};
+//#endregion
+//#region src/resources/organizations.ts
+const getOrganizationBillingFields = { path: ["organizationId"] };
+function reviveBillingPlan(value) {
+	if (value.periodEnd != null) value.periodEnd = decoded("BillingPlan.periodEnd", value.periodEnd, (raw) => new Date(raw));
+}
+function reviveOrganizationBilling(value) {
+	if (value.plan != null) reviveBillingPlan(value.plan);
+}
+const getOrganizationBillingDescriptor = /* @__PURE__ */ callable({
+	address: "/organizations/{organizationId}/billing",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveOrganizationBilling) }
+});
+function reviveOrganization(value) {
+	if (value.createdAt != null) value.createdAt = decoded("Organization.createdAt", value.createdAt, (raw) => new Date(raw));
+}
+function reviveOrganizationList(value) {
+	if (value.data != null) value.data.forEach((item) => {
+		reviveOrganization(item);
+	});
+}
+const listOrganizationsDescriptor = /* @__PURE__ */ callable({
+	address: "/organizations",
+	auth: apiKeyRequirements,
+	method: "get",
+	pagination: {
+		items: "data",
+		limitParam: "limit",
+		pages: "pagination.totalPages",
+		param: "page",
+		size: "pagination.limit",
+		style: "page",
+		total: "pagination.total"
+	},
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveOrganizationList) }
+});
+const getOrganizationFields = { path: ["organizationId"] };
+const getOrganizationDescriptor = /* @__PURE__ */ callable({
+	address: "/organizations/{organizationId}",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveOrganization) }
+});
+/** Organizations, their plan limits, and their usage */
+var Billing = class extends ElmoResource {
+	/**
+	* Get billing state
+	*
+	* The organization's plan, its limits, and how much of each limit is already spent — enough for
+	* an integration to know a write will be rejected before attempting it.
+	*
+	* This endpoint is read-only by construction. No API key of any kind can change a subscription,
+	* an add-on quantity, or a payment method; there is no billing write endpoint and no billing
+	* write scope. Stripe identifiers, invoices, and payment methods are never returned.
+	*
+	* Deployments without billing answer `200` with `billingEnabled: false`, a null plan, and null
+	* limits, so callers need no special case.
+	*/
+	get(organizationId, options) {
+		return callPromise(options?.client ?? this.client, getOrganizationBillingDescriptor, mergeParams(placeParams({ organizationId }, getOrganizationBillingFields, "query"), options));
+	}
+};
+/** Organizations, their plan limits, and their usage */
+var Organizations = class extends ElmoResource {
+	/**
+	* Get an organization
+	*
+	* No scope required. An organization outside the key's reach answers `404`, identically to one
+	* that does not exist.
+	*/
+	get(organizationId, options) {
+		return callPromise(options?.client ?? this.client, getOrganizationDescriptor, mergeParams(placeParams({ organizationId }, getOrganizationFields, "query"), options));
+	}
+	/**
+	* One entry for an organization key — the one it acts inside. Every organization for an instance
+	* admin key. No scope required: a key can only ever see the organization it is already bound to.
+	*/
+	list(params, options) {
+		return pages(options?.client ?? this.client, listOrganizationsDescriptor, mergeParams(groupParams(params, "query"), options));
+	}
+	_billing;
+	/** Organizations, their plan limits, and their usage */
+	get billing() {
+		return this._billing ??= new Billing(this.client);
+	}
+};
+//#endregion
+//#region src/resources/runs.ts
+const listPromptRunsFields = { path: ["promptId"] };
+function reviveRunSummary(value) {
+	if (value.createdAt != null) value.createdAt = decoded("RunSummary.createdAt", value.createdAt, (raw) => new Date(raw));
+}
+function reviveRunList(value) {
+	if (value.data != null) value.data.forEach((item) => {
+		reviveRunSummary(item);
+	});
+}
+const listPromptRunsDescriptor = /* @__PURE__ */ callable({
+	address: "/prompts/{promptId}/runs",
+	auth: apiKeyRequirements,
+	method: "get",
+	pagination: {
+		items: "data",
+		limitParam: "limit",
+		pages: "pagination.totalPages",
+		param: "page",
+		size: "pagination.limit",
+		style: "page",
+		total: "pagination.total"
+	},
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveRunList) }
+});
+const getRunFields = { path: ["promptId", "runId"] };
+function reviveRun(value) {
+	if (value.createdAt != null) value.createdAt = decoded("Run.createdAt", value.createdAt, (raw) => new Date(raw));
+}
+const getRunDescriptor = /* @__PURE__ */ callable({
+	address: "/prompts/{promptId}/runs/{runId}",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(reviveRun) }
+});
+/** Individual model answers behind the aggregates */
+var Runs = class extends ElmoResource {
+	/**
+	* Get a run
+	*
+	* One model answer, with its text normalized out of the provider’s response and its citations in
+	* the order the engine listed them. A run belonging to some other prompt answers `404`. The
+	* provider’s raw payload is deliberately not exposed — its shape belongs to the provider, not to
+	* this API.
+	*/
+	get(promptId, runId, options) {
+		return callPromise(options?.client ?? this.client, getRunDescriptor, mergeParams(placeParams({
+			promptId,
+			runId
+		}, getRunFields, "query"), options));
+	}
+	/**
+	* List runs for a prompt
+	*
+	* Individual model answers behind the aggregates, newest first, without their text — the list
+	* stays small enough to page through. Fetch `prompts.runs.get()` for the answer itself.
+	*/
+	list(promptId, params, options) {
+		return pages(options?.client ?? this.client, listPromptRunsDescriptor, mergeParams(placeParams({
+			...params,
+			promptId
+		}, listPromptRunsFields, "query"), options));
+	}
+};
+//#endregion
+//#region src/resources/snapshots.ts
+const getPromptSnapshotFields = { path: ["promptId"] };
+const getPromptSnapshotDescriptor = /* @__PURE__ */ callable({
+	address: "/prompts/{promptId}/snapshot",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json"
+});
+/** Aggregated analytics snapshots for prompts */
+var Snapshot = class extends ElmoResource {
+	/**
+	* Get an aggregated snapshot of mention and citation analytics for a specific prompt over a date
+	* range. Use this to identify competitive gaps, track brand visibility trends, and discover top
+	* cited URLs.
+	*
+	* @param promptId The ID of the prompt
+	*/
+	get(promptId, params, options) {
+		return callPromise(options?.client ?? this.client, getPromptSnapshotDescriptor, mergeParams(placeParams({
+			...params,
+			promptId
+		}, getPromptSnapshotFields, "query"), options));
+	}
+};
+//#endregion
+//#region src/resources/prompts.ts
+function revivePrompt(value) {
+	if (value.createdAt != null) value.createdAt = decoded("Prompt.createdAt", value.createdAt, (raw) => new Date(raw));
+	if (value.updatedAt != null) value.updatedAt = decoded("Prompt.updatedAt", value.updatedAt, (raw) => new Date(raw));
+}
+const listPromptsDescriptor = /* @__PURE__ */ callable({
+	address: "/prompts",
+	auth: apiKeyRequirements,
+	method: "get",
+	pagination: {
+		items: "data",
+		limitParam: "limit",
+		pages: "pagination.totalPages",
+		param: "page",
+		size: "pagination.limit",
+		style: "page",
+		total: "pagination.total"
+	},
+	returns: "json",
+	validators: { response: (data) => {
+		const value = data;
+		if (value == null) return value;
+		if (value.data != null) value.data.forEach((item) => {
+			revivePrompt(item);
+		});
+		if (value.prompts != null) value.prompts.forEach((item) => {
+			revivePrompt(item);
+		});
+		return value;
+	} }
+});
+const createPromptDescriptor = /* @__PURE__ */ callable({
+	address: "/prompts",
+	auth: apiKeyRequirements,
+	mediaType: "application/json",
+	method: "post",
+	returns: "json",
+	rules: [valueRule],
+	validators: { response: /* @__PURE__ */ reviving(revivePrompt) }
+});
+const deletePromptFields = { path: ["promptId"] };
+const deletePromptDescriptor = /* @__PURE__ */ callable({
+	address: "/prompts/{promptId}",
+	auth: apiKeyRequirements,
+	method: "delete",
+	returns: "json",
+	validators: { response: (data) => {
+		const value = data;
+		if (value == null) return value;
+		if (value.createdAt != null) value.createdAt = decoded("createdAt", value.createdAt, (raw) => new Date(raw));
+		if (value.updatedAt != null) value.updatedAt = decoded("updatedAt", value.updatedAt, (raw) => new Date(raw));
+		return value;
+	} }
+});
+const getPromptFields = { path: ["promptId"] };
+const getPromptDescriptor = /* @__PURE__ */ callable({
+	address: "/prompts/{promptId}",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: /* @__PURE__ */ reviving(revivePrompt) }
+});
+const updatePromptFields = { path: ["promptId"] };
+const updatePromptDescriptor = /* @__PURE__ */ callable({
+	address: "/prompts/{promptId}",
+	auth: apiKeyRequirements,
+	mediaType: "application/json",
+	method: "patch",
+	returns: "json",
+	rules: [valueRule],
+	validators: { response: /* @__PURE__ */ reviving(revivePrompt) }
+});
+/** Manage brand prompts */
+var Prompts = class extends ElmoResource {
+	/**
+	* Create a new prompt
+	*
+	* Create a new prompt for a brand. This will automatically schedule the prompt for execution.
+	*/
+	create(params, options) {
+		return callPromise(options?.client ?? this.client, createPromptDescriptor, mergeParams(groupParams(params, "body"), options));
+	}
+	/**
+	* Delete a prompt
+	*
+	* Permanently delete a prompt and cancel all related scheduled jobs. This will also cascade
+	* delete all associated prompt runs.
+	*
+	* Requires an instance admin key; organization keys receive `403`. The dashboard has no delete
+	* either — stop tracking a prompt with `prompts.update()` and `enabled: false`, which keeps its
+	* history and frees the plan slot.
+	*
+	* @param promptId The ID of the prompt to delete
+	*/
+	delete(promptId, options) {
+		return callPromise(options?.client ?? this.client, deletePromptDescriptor, mergeParams(placeParams({ promptId }, deletePromptFields, "query"), options));
+	}
+	/**
+	* Get a prompt
+	*
+	* Retrieve a specific prompt by ID
+	*
+	* @param promptId The ID of the prompt
+	*/
+	get(promptId, options) {
+		return callPromise(options?.client ?? this.client, getPromptDescriptor, mergeParams(placeParams({ promptId }, getPromptFields, "query"), options));
+	}
+	/**
+	* List all prompts
+	*
+	* Retrieve a paginated list of all prompts across all brands
+	*/
+	list(params, options) {
+		return pages(options?.client ?? this.client, listPromptsDescriptor, mergeParams(groupParams(params, "query"), options));
+	}
+	/**
+	* Update a prompt
+	*
+	* Update a prompt's properties. Only provided fields will be updated. Toggling `enabled`
+	* schedules or unschedules the recurring run job.
+	*
+	* @param promptId The ID of the prompt to update
+	*/
+	update(promptId, params, options) {
+		return callPromise(options?.client ?? this.client, updatePromptDescriptor, mergeParams(placeParams({
+			...params,
+			promptId
+		}, updatePromptFields, "body"), options));
+	}
+	_runs;
+	/** Individual model answers behind the aggregates */
+	get runs() {
+		return this._runs ??= new Runs(this.client);
+	}
+	_snapshot;
+	/** Aggregated analytics snapshots for prompts */
+	get snapshot() {
+		return this._snapshot ??= new Snapshot(this.client);
+	}
+};
+//#endregion
+//#region src/resources/reports.ts
+function reviveReportSummary(value) {
+	if (value.createdAt != null) value.createdAt = decoded("ReportSummary.createdAt", value.createdAt, (raw) => new Date(raw));
+	if (value.completedAt != null) value.completedAt = decoded("ReportSummary.completedAt", value.completedAt, (raw) => new Date(raw));
+}
+const listReportsDescriptor = /* @__PURE__ */ callable({
+	address: "/reports",
+	auth: apiKeyRequirements,
+	method: "get",
+	pagination: {
+		items: "data",
+		limitParam: "limit",
+		pages: "pagination.totalPages",
+		param: "page",
+		size: "pagination.limit",
+		style: "page",
+		total: "pagination.total"
+	},
+	returns: "json",
+	validators: { response: (data) => {
+		const value = data;
+		if (value == null) return value;
+		if (value.data != null) value.data.forEach((item) => {
+			reviveReportSummary(item);
+		});
+		if (value.reports != null) value.reports.forEach((item) => {
+			reviveReportSummary(item);
+		});
+		return value;
+	} }
+});
+const createReportDescriptor = /* @__PURE__ */ callable({
+	address: "/reports",
+	auth: apiKeyRequirements,
+	mediaType: "application/json",
+	method: "post",
+	returns: "json",
+	rules: [
+		brandNameRule,
+		{
+			max: 10,
+			name: "brandAliases",
+			of: "items"
+		},
+		{
+			min: 1,
+			name: "brandWebsite",
+			of: "characters"
+		}
+	],
+	validators: { response: (data) => {
+		const value = data;
+		if (value == null) return value;
+		if (value.createdAt != null) value.createdAt = decoded("createdAt", value.createdAt, (raw) => new Date(raw));
+		return value;
+	} }
+});
+const getReportFields = { path: ["reportId"] };
+const getReportDescriptor = /* @__PURE__ */ callable({
+	address: "/reports/{reportId}",
+	auth: apiKeyRequirements,
+	method: "get",
+	returns: "json",
+	validators: { response: (data) => {
+		const value = data;
+		if (value == null) return value;
+		if (value.createdAt != null) value.createdAt = decoded("createdAt", value.createdAt, (raw) => new Date(raw));
+		if (value.completedAt != null) value.completedAt = decoded("completedAt", value.completedAt, (raw) => new Date(raw));
+		return value;
+	} }
+});
+/** Generate and retrieve AI Share of Voice reports */
+var Reports = class extends ElmoResource {
+	/**
+	* Create a report
+	*
+	* Create a new AI Share of Voice report and queue it for generation. The report will evaluate the
+	* brand across multiple AI engines (ChatGPT, Claude, Google AI) using generated and optional
+	* custom prompts.
+	*
+	* Requires an instance admin key; organization keys receive `403`.
+	*/
+	create(params, options) {
+		return callPromise(options?.client ?? this.client, createReportDescriptor, mergeParams(groupParams(params, "body"), options));
+	}
+	/**
+	* Get report status and data
+	*
+	* Poll a report's status. When completed, returns per-prompt snapshot data with raw mention
+	* counts. Consumers are responsible for computing SoV and other derived metrics from the raw
+	* data.
+	*
+	* Requires an instance admin key; organization keys receive `403`.
+	*
+	* @param reportId The ID of the report
+	*/
+	get(reportId, params, options) {
+		return callPromise(options?.client ?? this.client, getReportDescriptor, mergeParams(placeParams({
+			...params,
+			reportId
+		}, getReportFields, "query"), options));
+	}
+	/**
+	* Retrieve a paginated list of all reports, ordered by creation date (newest first).
+	*
+	* Requires an instance admin key; organization keys receive `403`.
+	*/
+	list(params, options) {
+		return pages(options?.client ?? this.client, listReportsDescriptor, mergeParams(groupParams(params, "query"), options));
+	}
+};
+//#endregion
+//#region src/resources/tools.ts
+const analyzeBrandDescriptor = /* @__PURE__ */ callable({
+	address: "/tools/analyze",
+	auth: apiKeyRequirements,
+	mediaType: "application/json",
+	method: "post",
+	returns: "json",
+	rules: [
+		{
+			min: 1,
+			name: "website",
+			of: "characters"
+		},
+		{
+			max: 100,
+			min: 0,
+			name: "maxCompetitors"
+		},
+		{
+			max: 100,
+			min: 0,
+			name: "maxPrompts"
+		}
+	]
+});
+/** One-shot helpers (e.g. brand analysis) that don't persist anything */
+var Tools = class extends ElmoResource {
+	/**
+	* Analyze a website
+	*
+	* Run brand analysis without persisting anything. Returns suggested additional domains, aliases,
+	* competitors, and prompts.
+	*
+	* Requires an instance admin key; organization keys receive `403`.
+	*/
+	analyze(params, options) {
+		return callPromise(options?.client ?? this.client, analyzeBrandDescriptor, mergeParams(groupParams(params, "body"), options));
+	}
+};
+//#endregion
+export { getBrandOpportunitiesFields as $, listModelsDescriptor as A, selectCodec as At, updateCompetitorDescriptor as B, emptyPathParameter as Bt, Organizations as C, isFieldValue as Ct, getOrganizationFields as D, toText as Dt, getOrganizationDescriptor as E, scalarText as Et, deleteCompetitorDescriptor as F, MissingCredentialError as Ft, getBrandFields as G, unansweredError as Gt, Brands as H, isStructured as Ht, deleteCompetitorFields as I, TimeoutError as It, updateBrandFields as J, TIMER_LIMIT as Jt, listBrandsDescriptor as K, unsendable as Kt, getCompetitorDescriptor as L, TransportError as Lt, getMeDescriptor as M, AbortError as Mt, Competitors as N, DecodeError as Nt, listOrganizationsDescriptor as O, essenceOf as Ot, createCompetitorDescriptor as P, ElmoError as Pt, getBrandOpportunitiesDescriptor as Q, sleep as Qt, getCompetitorFields as R, calledOffWith as Rt, listPromptRunsFields as S, createConfig as St, getOrganizationBillingFields as T, metadataValue as Tt, createBrandDescriptor as U, refusedInput as Ut, updateCompetitorFields as V, failureOf as Vt, getBrandDescriptor as W, safeAddress as Wt, listBrandTagsDescriptor as X, exceedsMaxRetryAfter as Xt, pages as Y, backoffDelay as Yt, listBrandTagsFields as Z, retryAfterDelay as Zt, getPromptSnapshotDescriptor as _, createClient as _t, getReportDescriptor as a, listBrandCitationDomainsFields as at, getRunFields as b, replyWith as bt, Prompts as c, listBrandPromptPerformanceDescriptor as ct, deletePromptFields as d, mergeParams as dt, getBrandAnalyticsDescriptor as et, getPromptDescriptor as f, placeParams as ft, updatePromptFields as g, clientFor as gt, updatePromptDescriptor as h, validateFeature as ht, createReportDescriptor as i, listBrandCitationDomainsDescriptor as it, Me as j, APIError as jt, Models as k, readText as kt, createPromptDescriptor as l, listBrandPromptPerformanceFields as lt, listPromptsDescriptor as m, ElmoResource as mt, analyzeBrandDescriptor as n, getBrandQueryFanoutDescriptor as nt, getReportFields as o, listBrandCitationURLsDescriptor as ot, getPromptFields as p, callPromise as pt, updateBrandDescriptor as q, unsendableAddress as qt, Reports as r, getBrandQueryFanoutFields as rt, listReportsDescriptor as s, listBrandCitationUrlsFields as st, Tools as t, getBrandAnalyticsFields as tt, deletePromptDescriptor as u, groupParams as ut, getPromptSnapshotFields as v, discardBody as vt, getOrganizationBillingDescriptor as w, metadataHeaders as wt, listPromptRunsDescriptor as x, baseURLOf as xt, getRunDescriptor as y, isStreamed as yt, listCompetitorsDescriptor as z, classifyError as zt };
+
+//# sourceMappingURL=tools-SwP0sK8H.mjs.map