@elmohq/sdk 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1029 @@
+import { At as selectCodec, Bt as emptyPathParameter, C as Organizations, Ct as isFieldValue, Dt as toText, Et as scalarText, Ft as MissingCredentialError, Gt as unansweredError, H as Brands, Ht as isStructured, It as TimeoutError, Jt as TIMER_LIMIT, Kt as unsendable, Lt as TransportError, Mt as AbortError, N as Competitors, Nt as DecodeError, Ot as essenceOf, Pt as ElmoError, Qt as sleep, Rt as calledOffWith, St as createConfig, Tt as metadataValue, Ut as refusedInput, Vt as failureOf, Wt as safeAddress, Xt as exceedsMaxRetryAfter, Yt as backoffDelay, Zt as retryAfterDelay, _t as createClient, bt as replyWith, c as Prompts, gt as clientFor, ht as validateFeature, j as Me, jt as APIError, k as Models, kt as readText, mt as ElmoResource, qt as unsendableAddress, r as Reports, t as Tools, vt as discardBody, wt as metadataHeaders, xt as baseURLOf, yt as isStreamed, zt as classifyError } from "./tools-SwP0sK8H.mjs";
+//#region src/internal/binding/rest/errors.ts
+function undeclaredBody(response, value) {
+	const where = response.url ? ` for "${safeAddress(response.url)}"` : "";
+	const contentType = response.headers.get("content-type");
+	const said = contentType ? ` Its content type said "${contentType}".` : "";
+	const got = value === null || value === void 0 ? "no JSON object or list, where the API description declares one." : `a body that is not the JSON object or list the API description declares.${said}`;
+	return new DecodeError(`The API answered ${response.status}${where} with ${got}`, {
+		response,
+		value
+	});
+}
+function unreadableBody(response, cause) {
+	const where = response.url ? ` for "${safeAddress(response.url)}"` : "";
+	const contentType = response.headers.get("content-type");
+	const said = contentType ? ` Its content type said "${contentType}".` : "";
+	return new DecodeError(`The API answered ${response.status}${where} with a body this client could not read.${said}`, {
+		cause,
+		response
+	});
+}
+/** The API could not read the request, so it did not act on it. */
+var BadRequestError = class extends APIError {
+	name = "BadRequestError";
+};
+/** No usable credential reached the API: it was missing, unreadable, or rejected. */
+var AuthenticationError = class extends APIError {
+	name = "AuthenticationError";
+};
+/** The plan or the quota on this account does not cover the call. */
+var PaymentRequiredError = class extends APIError {
+	name = "PaymentRequiredError";
+};
+/** The credential was accepted, but it does not grant this call. */
+var PermissionDeniedError = class extends APIError {
+	name = "PermissionDeniedError";
+};
+/** Nothing is at this address, or the credential may not see what is. */
+var NotFoundError = class extends APIError {
+	name = "NotFoundError";
+};
+/** The call collided with the resource's current state: a duplicate, or a concurrent change. */
+var ConflictError = class extends APIError {
+	name = "ConflictError";
+};
+/** The request was read, and its contents were rejected. */
+var UnprocessableEntityError = class extends APIError {
+	name = "UnprocessableEntityError";
+};
+/** Too many calls. {@link APIError.retryAfterMs} carries how long the API asked to wait. */
+var RateLimitError = class extends APIError {
+	name = "RateLimitError";
+};
+const BY_STATUS = {
+	400: BadRequestError,
+	401: AuthenticationError,
+	402: PaymentRequiredError,
+	403: PermissionDeniedError,
+	404: NotFoundError,
+	409: ConflictError,
+	422: UnprocessableEntityError,
+	429: RateLimitError
+};
+/** The API failed after accepting the call. Every status from 500 up arrives as this. */
+var InternalServerError = class extends APIError {
+	name = "InternalServerError";
+};
+function toAPIError(status, error, response, unauthenticated) {
+	return new (BY_STATUS[status] ?? (status >= 500 ? InternalServerError : APIError))(status, error, response, status === 401 || status === 403 ? unauthenticated?.() : void 0);
+}
+//#endregion
+//#region src/internal/binding/rest/binding.ts
+const DEFAULT_ACCEPT = "application/json";
+function placeInHeader(credential, request) {
+	request.meta[credential.name.toLowerCase()] = credential.value;
+}
+const PLACERS = { header: placeInHeader };
+function declaredReply(value, raw, request) {
+	if (request.callable.returns !== "json" || isStructured(value)) return value;
+	throw undeclaredBody(raw, value);
+}
+function parserFor(contentType) {
+	if (!contentType) return "text";
+	const essence = essenceOf(contentType);
+	if (essence === "application/json" || essence.endsWith("+json")) return "json";
+	if (essence.startsWith("text/")) return "text";
+	return "blob";
+}
+function asksForJSON(request) {
+	const accept = metadataValue(request.meta["accept"]);
+	return !!accept && accept.split(",").every((one) => parserFor(one) === "json");
+}
+function jsonOrText(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+async function readBody(raw, request, codecs = []) {
+	if (raw.body === null || raw.headers.get("content-length") === "0") return null;
+	const contentType = raw.headers.get("content-type");
+	const codec = selectCodec(codecs, contentType ?? void 0);
+	const parser = parserFor(contentType);
+	const copy = raw.ok ? void 0 : raw.clone();
+	try {
+		if (codec?.decode) return await codec.decode(raw);
+		if (parser === "blob") return await raw.blob();
+		const text = await readText(raw, parser === "json");
+		if (text === "") return null;
+		if (parser === "json") return JSON.parse(text);
+		return asksForJSON(request) ? jsonOrText(text) : text;
+	} catch (error) {
+		if (error instanceof ElmoError) throw error;
+		if (classifyError(error) === "abort") throw unansweredError(error);
+		if (copy) return readText(copy).catch(() => {
+			throw unreadableBody(raw, error);
+		});
+		throw unreadableBody(raw, error);
+	}
+}
+function createRestBinding(buildURL) {
+	return {
+		accept: DEFAULT_ACCEPT,
+		applyAuth(credential, request) {
+			const place = PLACERS[credential.in];
+			if (!place) throw new ElmoError(`This client places no credential in the ${credential.in}, so "${request.callable.address}" cannot be authenticated.`);
+			place(credential, request);
+		},
+		name: "rest",
+		readError(result, request) {
+			const { response } = result;
+			if (!response || response.ok && result.error === void 0) return;
+			return toAPIError(response.status, result.error, response, request.unauthenticated);
+		},
+		async readResult(raw, request, codecs) {
+			if (request.options.unread) return {
+				ok: raw.ok,
+				response: raw,
+				status: raw.status
+			};
+			const value = raw.status === 204 || raw.status === 205 ? null : await readBody(raw, request, codecs);
+			return raw.ok ? {
+				data: declaredReply(value, raw, request),
+				ok: true,
+				response: raw,
+				status: raw.status
+			} : {
+				error: value,
+				ok: false,
+				response: raw,
+				status: raw.status
+			};
+		},
+		resolveAddress(callable, options) {
+			return buildURL({
+				address: callable.address,
+				baseURL: baseURLOf(options, callable.baseURL),
+				path: options.path,
+				query: options.query,
+				serialization: callable.serialization
+			});
+		}
+	};
+}
+//#endregion
+//#region src/internal/binding/rest/path.ts
+function encodeValue(value) {
+	return encodeURIComponent(toText(value));
+}
+function encodeName(name) {
+	return encodeURIComponent(name).replace(/%5B/g, "[").replace(/%5D/g, "]");
+}
+//#endregion
+//#region src/internal/binding/rest/url.ts
+const NAMED_PATH_PARAM_RE = /\{([^{}]+)\}/g;
+const ABSOLUTE_URL_RE = /^[a-z][a-z\d+.-]*:\/\//i;
+function joinPath(base, path) {
+	return base.endsWith("/") && path.startsWith("/") ? base + path.slice(1) : base + path;
+}
+function joinURL(baseURL, path) {
+	const base = baseURL ?? "";
+	const hash = base.indexOf("#");
+	const kept = hash === -1 ? base : base.slice(0, hash);
+	const mark = kept.indexOf("?");
+	if (mark === -1) return joinPath(kept, path);
+	const joined = joinPath(kept.slice(0, mark), path);
+	const query = kept.slice(mark + 1);
+	if (!query) return joined;
+	return `${joined}${joined.includes("?") ? "&" : "?"}${query}`;
+}
+function addressURL(address, baseURL) {
+	const absolute = ABSOLUTE_URL_RE.test(address);
+	const pathURL = absolute || address.startsWith("/") ? address : `/${address}`;
+	return absolute ? pathURL : joinURL(baseURL, pathURL);
+}
+function pathValue(value) {
+	if (Array.isArray(value)) return value.map(encodeValue).join(",");
+	if (typeof value === "object" && value !== null && scalarText(value) === void 0) return Object.entries(value).flatMap(([key, item]) => [encodeURIComponent(key), encodeValue(item)]).join(",");
+	return encodeValue(value);
+}
+function filledURL(address, baseURL, path) {
+	const url = addressURL(address, baseURL);
+	if (!path) return url;
+	return url.replace(NAMED_PATH_PARAM_RE, (_match, name) => {
+		const value = path[name];
+		if (value === void 0 || value === null || value === "") throw emptyPathParameter(name, address);
+		return pathValue(value);
+	});
+}
+function withQuery(url, query) {
+	if (!query) return url;
+	const search = [];
+	for (const [name, value] of Object.entries(query)) {
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (item !== void 0 && item !== null) search.push(`${encodeName(name)}=${encodeValue(item)}`);
+			continue;
+		}
+		if (typeof value === "object" && scalarText(value) === void 0) {
+			for (const [key, item] of Object.entries(value)) if (item !== void 0 && item !== null) search.push(`${encodeName(key)}=${encodeValue(item)}`);
+			continue;
+		}
+		search.push(`${encodeName(name)}=${encodeValue(value)}`);
+	}
+	if (!search.length) return url;
+	return `${url}${url.includes("?") ? "&" : "?"}${search.join("&")}`;
+}
+const simpleURL = ({ address, baseURL, path, query }) => withQuery(filledURL(address, baseURL, path), query);
+//#endregion
+//#region src/internal/codec/json.ts
+function finite(value) {
+	if (!Number.isFinite(value)) throw new ElmoError("NaN and Infinity cannot be written as JSON.");
+	return value;
+}
+function refused(value) {
+	const name = typeof value === "object" && value !== null ? value.constructor?.name ?? "Object" : typeof value;
+	return new ElmoError(`A value of type ${name} cannot be written as JSON.`);
+}
+function mapKey(key) {
+	if (typeof key === "number") return String(finite(key));
+	if (typeof key === "string" || typeof key === "boolean" || typeof key === "bigint") return String(key);
+	throw refused(key);
+}
+function jsonValue(_key, value) {
+	if (typeof value === "bigint") return value.toString();
+	if (typeof value === "number") return finite(value);
+	if (typeof value !== "object" || value === null) return value;
+	if (value instanceof Set) return [...value];
+	if (value instanceof Map) return Object.fromEntries([...value].map(([key, item]) => [mapKey(key), item]));
+	if (value instanceof ArrayBuffer || ArrayBuffer.isView(value) || typeof Blob !== "undefined" && value instanceof Blob) throw refused(value);
+	return value;
+}
+function jsonText(value) {
+	try {
+		return JSON.stringify(value, jsonValue);
+	} catch (error) {
+		if (error instanceof ElmoError) throw error;
+		throw new ElmoError(`A value cannot be written as JSON: ${error.message}`, { cause: error });
+	}
+}
+const jsonCodec = {
+	contentType: "application/json",
+	decode: async (raw) => {
+		const text = await readText(raw, true);
+		return text === "" ? null : JSON.parse(text);
+	},
+	encode: jsonText,
+	mediaTypes: ["application/json"],
+	name: "json"
+};
+//#endregion
+//#region src/internal/core/browser.ts
+function refuseBrowser(options) {
+	if (options["dangerouslyAllowBrowser"] === true) return;
+	const scope = globalThis;
+	if (scope.window === void 0 || scope.document === void 0) return;
+	throw new ElmoError("This client was built in a browser, where every visitor to the page can read the credential it sends. Build it on a server instead. If the credential is meant to be public, or a proxy adds it, pass `dangerouslyAllowBrowser: true`.");
+}
+//#endregion
+//#region src/internal/feature/auth.ts
+function schemesOf(requirement) {
+	return Array.isArray(requirement) ? requirement : [requirement];
+}
+function candidates(requirements, ..._environment) {
+	return requirements.map(schemesOf);
+}
+function formatBearer(token) {
+	return `Bearer ${token}`;
+}
+const SCHEME_FORMATS = { bearer: formatBearer };
+function formatToken(scheme, token, prefix) {
+	if (!token) return void 0;
+	if (prefix !== void 0) return `${prefix}${token}`;
+	const format = scheme.scheme ? SCHEME_FORMATS[scheme.scheme] : void 0;
+	return format ? format(token) : token;
+}
+function labeled(key, options) {
+	const variable = options?.schemes?.[key]?.variable;
+	return variable ? `\`${key}\` (\`${variable}\`)` : `\`${key}\``;
+}
+function credentialFor(scheme, token, options) {
+	const prefix = scheme.key ? options?.schemes?.[scheme.key]?.prefix : void 0;
+	const value = formatToken(scheme, token?.trim(), prefix);
+	if (!value) return void 0;
+	const credential = {
+		in: scheme.in ?? "header",
+		name: scheme.name ?? "Authorization",
+		value
+	};
+	if (credential.in !== "query" && !isFieldValue(value)) {
+		const held = scheme.key ? labeled(scheme.key, options) : `The credential \`auth\` returned for \`${credential.name}\``;
+		throw new MissingCredentialError(unsendable(held), scheme.key ? [scheme.key] : []);
+	}
+	return credential;
+}
+async function credentialsFor(schemes, ask, options) {
+	const placed = [];
+	for (const scheme of schemes) {
+		const credential = credentialFor(scheme, await ask(scheme), options);
+		if (!credential) return void 0;
+		placed.push({
+			credential,
+			scheme
+		});
+	}
+	return placed;
+}
+function keysOf(open) {
+	return [...new Set(open.flat())];
+}
+function conjoined(keys, options) {
+	return keys.map((key) => labeled(key, options)).join(" and ");
+}
+function either(alternatives) {
+	if (alternatives.length <= 2) return alternatives.join(" or ");
+	return `${alternatives.slice(0, -1).join(", ")}, or ${alternatives.at(-1)}`;
+}
+function advice(open, options) {
+	if (!open.length) return "";
+	const alternatives = open.map((keys) => conjoined(keys, options));
+	if (alternatives.length > 1 && open.some((keys) => keys.length > 1)) return ` Either ${alternatives.map((one) => `set ${one}`).join(", or ")}.`;
+	return ` Set ${either(alternatives)}.`;
+}
+function missing(open, options) {
+	return `This call needs a credential that was not set.${advice(open, options)}`;
+}
+function offered(alternatives) {
+	return alternatives.map((schemes) => schemes.map((scheme) => scheme.key).filter((key) => key !== void 0)).filter((keys) => keys.length > 0);
+}
+async function tokenFor(scheme, held, options) {
+	const stated = scheme.key !== void 0 && options?.schemes?.[scheme.key]?.option !== false ? held[scheme.key] : void 0;
+	const value = typeof stated === "function" ? await stated() : stated;
+	return typeof held.auth === "function" ? held.auth(scheme, value) : value;
+}
+function unauthenticated(open, options) {
+	return `This call was sent with no credential.${advice(open, options)}`;
+}
+function writtenByHand(scheme, request) {
+	return (scheme.in ?? "header") === "header" && request.meta[(scheme.name ?? "Authorization").toLowerCase()] !== void 0;
+}
+function authFeature(options) {
+	return {
+		name: "auth",
+		async onPrepare(request, ctx) {
+			const declared = request.callable.auth;
+			if (!declared?.length) return;
+			const { auth, environment } = request.options;
+			const alternatives = candidates(declared, environment, options).map((schemes) => schemes.filter((scheme) => !writtenByHand(scheme, request)));
+			const asked = /* @__PURE__ */ new Map();
+			function ask(scheme) {
+				const key = scheme.key ?? scheme;
+				let token = asked.get(key);
+				if (!token) {
+					token = tokenFor(scheme, request.options, options);
+					asked.set(key, token);
+				}
+				return token;
+			}
+			if (auth !== null) {
+				for (const schemes of alternatives) {
+					const placed = await credentialsFor(schemes, ask, options);
+					if (!placed) continue;
+					for (const { credential } of placed) ctx.binding.applyAuth(credential, request);
+					request.placed = placed;
+					return;
+				}
+				await void 0;
+			}
+			const all = offered(declared.map(schemesOf));
+			if (auth === null || request.callable.authOptional) {
+				request.unauthenticated = () => unauthenticated(all, options);
+				return;
+			}
+			throw new MissingCredentialError(missing(all, options), keysOf(all));
+		}
+	};
+}
+//#endregion
+//#region src/internal/feature/interceptors.ts
+function interceptorsOf(request) {
+	return request.options["interceptors"];
+}
+function interceptorsFeature() {
+	return {
+		name: "interceptors",
+		async onError(error, request) {
+			let current = error;
+			for (const fn of interceptorsOf(request)?.error ?? []) current = await fn(current, request);
+			return current;
+		},
+		async onRequest(request) {
+			for (const fn of interceptorsOf(request)?.request ?? []) await fn(request);
+		},
+		async onResult(result, request) {
+			let current = result;
+			for (const fn of interceptorsOf(request)?.response ?? []) current = await fn(current, request);
+			return current;
+		}
+	};
+}
+//#endregion
+//#region src/internal/feature/logger.ts
+const LEVELS = {
+	debug: 40,
+	error: 10,
+	info: 30,
+	off: 0,
+	warn: 20
+};
+function describeCall(request) {
+	const method = request.callable.method?.toUpperCase();
+	const address = typeof request.address === "string" ? safeAddress(request.address) : "";
+	return method ? `${method} ${address}` : address;
+}
+const ADDRESS_RE = /\b[a-z][a-z\d+.-]*:\/\/[^\s"'<>]+/gi;
+function failureText(error) {
+	const messages = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current !== void 0 && current !== null && !seen.has(current)) {
+		seen.add(current);
+		const failed = current instanceof Error;
+		messages.push(failed ? current.message : String(current));
+		current = failed ? current.cause : void 0;
+	}
+	return messages.join(" Caused by: ").replace(ADDRESS_RE, safeAddress);
+}
+function declaredHeaders(callable) {
+	const names = /* @__PURE__ */ new Set();
+	for (const requirement of callable.auth ?? []) for (const scheme of Array.isArray(requirement) ? requirement : [requirement]) if (scheme.in === "header" && scheme.name) names.add(scheme.name.toLowerCase());
+	return names;
+}
+const SECRET_HEADERS = [
+	"authorization",
+	"cookie",
+	"proxy-authorization",
+	"set-cookie"
+];
+function isSecret(name, declared) {
+	const lower = name.toLowerCase();
+	return SECRET_HEADERS.includes(lower) || declared.has(lower) || lower.endsWith("-key") || lower.endsWith("-token") || lower.endsWith("-secret");
+}
+function safeHeaders(meta, callable) {
+	const declared = declaredHeaders(callable);
+	const safe = {};
+	for (const [name, value] of Object.entries(meta)) safe[name] = isSecret(name, declared) ? "***" : value;
+	return safe;
+}
+function callLog(id, request, at, sink) {
+	const label = describeCall(request);
+	let started = Date.now();
+	function line(text) {
+		return `[${id}] ${label} ${text}`;
+	}
+	return {
+		ended(error) {
+			const ms = Date.now() - started;
+			if (error !== void 0) {
+				if (at >= LEVELS.error) sink.error(line(`stream failed after ${ms} ms: ${failureText(error)}`));
+			} else if (at >= LEVELS.info) sink.info(line(`stream ended after ${ms} ms`));
+		},
+		failed(error) {
+			if (at >= LEVELS.error) sink.error(line(`failed: ${failureText(error)}`));
+		},
+		replied(response) {
+			const ms = Date.now() - started;
+			if (response?.redirected && at >= LEVELS.warn) sink.warn(line(`was redirected to ${safeAddress(response.url)}`));
+			if (at >= LEVELS.info) sink.info(line(`→ ${response?.status ?? "?"} in ${ms} ms`));
+			if (at >= LEVELS.debug) sink.debug(`[${id}] received`, {
+				headers: safeHeaders(Object.fromEntries(response?.headers ?? []), request.callable),
+				ms,
+				status: response?.status
+			});
+		},
+		retrying(wait, retry, retries, after) {
+			if (at < LEVELS.warn) return;
+			const again = `retrying in ${Math.round(wait)} ms (${retry} of ${retries})`;
+			if (after?.status !== void 0) sink.warn(line(`→ ${after.status}, ${again}`));
+			else if (after?.error !== void 0) sink.warn(line(`failed: ${failureText(after.error)}, ${again}`));
+			else sink.warn(line(again));
+		},
+		sending() {
+			started = Date.now();
+			if (at >= LEVELS.info) sink.info(`[${id}] ${label}`);
+			if (at >= LEVELS.debug) sink.debug(`[${id}] sending`, { headers: safeHeaders(request.meta, request.callable) });
+		}
+	};
+}
+function readLevel(named) {
+	const spelled = named.toLowerCase();
+	if (spelled === "warning") return "warn";
+	return Object.prototype.hasOwnProperty.call(LEVELS, spelled) ? spelled : void 0;
+}
+function resolveLogging(base, request, unknown) {
+	const named = String(request.options["logLevel"] || base.level || "off");
+	const level = readLevel(named);
+	const sink = request.options["logger"] ?? base.logger ?? globalThis.console;
+	if (level === void 0 && sink && !unknown.has(named)) {
+		unknown.add(named);
+		sink.warn(`Unknown log level "${named}": nothing is logged. Use "debug", "info", "warn", "error" or "off".`);
+	}
+	if (level === void 0 || level === "off" || !sink) return void 0;
+	return {
+		at: LEVELS[level],
+		sink
+	};
+}
+async function written(request, next) {
+	const { log } = request;
+	if (!log) return next(request);
+	const result = await next(request);
+	log.replied(result.response);
+	return result;
+}
+function loggerFeature(options = {}) {
+	let counter = 0;
+	const unknown = /* @__PURE__ */ new Set();
+	const warned = /* @__PURE__ */ new Set();
+	return {
+		name: "logger",
+		async onError(error, request) {
+			request.log?.failed(error);
+			return error;
+		},
+		onOpen: written,
+		onPrepare(request) {
+			const on = resolveLogging(options, request, unknown);
+			if (!on) return;
+			const id = `req_${++counter}`;
+			request.log = callLog(id, request, on.at, on.sink);
+			const { callable } = request;
+			if (callable.deprecated && on.at >= LEVELS.warn && !warned.has(callable)) {
+				warned.add(callable);
+				const method = callable.method?.toUpperCase();
+				const operation = method ? `${method} ${callable.address}` : callable.address;
+				on.sink.warn(`[${id}] ${operation} is deprecated`);
+			}
+		},
+		onSend: written
+	};
+}
+function askedFor(config, result) {
+	const headers = config.retryAfter;
+	if (headers === false || !result.response) return void 0;
+	return retryAfterDelay(result.response, headers === true ? void 0 : headers);
+}
+const IDEMPOTENT_METHODS = [
+	"DELETE",
+	"GET",
+	"HEAD",
+	"OPTIONS",
+	"PUT",
+	"TRACE"
+];
+function isRepeatable(config, request) {
+	const method = request.callable.method?.toUpperCase();
+	if (!method) return false;
+	if ((config.methods ?? IDEMPOTENT_METHODS).includes(method)) return true;
+	const { idempotency } = request.callable;
+	return idempotency !== void 0 && request.meta[idempotency] !== void 0;
+}
+function retriesFor(base, override, request) {
+	if (override && override !== true && override.maxRetries !== void 0) return Math.max(0, override.maxRetries);
+	const retries = request.options["maxRetries"];
+	if (typeof retries === "number" && Number.isFinite(retries)) return Math.max(0, retries);
+	return base.maxRetries ?? 2;
+}
+function resolveRetry(base, request) {
+	const override = request.options["retry"];
+	if (override === false) return void 0;
+	const declared = request.callable.retry;
+	if (declared === false && override === void 0) return void 0;
+	const stated = declared ? {
+		...base,
+		...declared
+	} : base;
+	const config = override && override !== true ? {
+		...stated,
+		...override
+	} : stated;
+	const maxRetries = retriesFor(stated, override, request);
+	return maxRetries < 1 ? void 0 : {
+		...config,
+		maxRetries
+	};
+}
+const REFUSED_STATUSES = [
+	408,
+	425,
+	429
+];
+const RETRY_HEADER = "x-should-retry";
+const PERMANENT_STATUSES = [
+	501,
+	505,
+	506,
+	508,
+	510,
+	511
+];
+function worthAnotherAttempt(status) {
+	if (status >= 500) return !PERMANENT_STATUSES.includes(status);
+	return REFUSED_STATUSES.includes(status);
+}
+function shouldRetry(config, result, request, repeatable) {
+	const { response } = result;
+	if (!response) return false;
+	if (!repeatable && !REFUSED_STATUSES.includes(response.status)) return false;
+	if (config.retryOn) return config.retryOn(result, request);
+	if (response.headers.get(RETRY_HEADER) === "false") return false;
+	const { statuses } = config;
+	return statuses ? statuses.includes(response.status) : worthAnotherAttempt(response.status);
+}
+function shouldRetryError(config, error, request, repeatable) {
+	if (error instanceof ElmoError && !(error instanceof TransportError)) return false;
+	const kind = classifyError(error);
+	if (kind === "abort") return false;
+	if (failureOf(error).reachedServer !== "no" && !repeatable) return false;
+	if (config.retryOn) return config.retryOn({ error }, request);
+	return kind !== "timeout" || config.retryOnTimeout === true;
+}
+function retryFeature(options = {}) {
+	return {
+		name: "retry",
+		async onSend(request, next) {
+			const config = isStreamed(request.body) ? void 0 : resolveRetry(options, request);
+			if (!config) return next(request);
+			const attempts = (config.maxRetries ?? 2) + 1;
+			const repeatable = isRepeatable(config, request);
+			const started = Date.now();
+			for (let attempt = 0;; attempt++) {
+				const last = attempt >= attempts - 1;
+				let result;
+				let threw = false;
+				let wait;
+				if (attempt) request.attempt = attempt;
+				try {
+					result = await next(request);
+					if (last || !shouldRetry(config, result, request, repeatable)) return result;
+					wait = config.retryDelay?.(result, request, attempt);
+					if (wait === void 0) {
+						wait = askedFor(config, result);
+						if (exceedsMaxRetryAfter(wait, config.maxRetryAfter)) return result;
+					}
+				} catch (error) {
+					if (last || !shouldRetryError(config, error, request, repeatable)) throw error;
+					threw = true;
+					result = { error };
+					wait = config.retryDelay?.(result, request, attempt);
+				}
+				wait ??= backoffDelay(attempt, config);
+				if (config.budget !== void 0 && Date.now() - started + wait >= config.budget) {
+					if (threw) throw result.error;
+					return result;
+				}
+				discardBody(result);
+				request.log?.retrying(wait, attempt + 1, attempts - 1, result);
+				await sleep(wait, request.signal).catch((reason) => {
+					throw calledOffWith(reason);
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/internal/feature/rules.ts
+const COUNTED = {
+	characters: "character",
+	entries: "entry",
+	items: "item"
+};
+function brokenBound(rule, size) {
+	if (rule.min !== void 0 && size < rule.min) return ["at least", rule.min];
+	if (rule.max !== void 0 && size > rule.max) return ["at most", rule.max];
+	if (rule.above !== void 0 && size <= rule.above) return ["more than", rule.above];
+	if (rule.below !== void 0 && size >= rule.below) return ["less than", rule.below];
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function inputOf(options, name) {
+	if (name === void 0) return options.body;
+	return isPlainObject(options.body) ? options.body[name] : void 0;
+}
+function sizeOf(value, of) {
+	if (of === void 0) return typeof value === "number" || typeof value === "bigint" ? value : void 0;
+	if (of === "characters") return typeof value === "string" ? Array.from(value).length : void 0;
+	if (of === "items") return Array.isArray(value) ? value.length : void 0;
+	if (!isPlainObject(value)) return void 0;
+	return Object.values(value).filter((entry) => entry !== void 0).length;
+}
+function rulesFeature() {
+	return {
+		name: "rules",
+		onOptions(options, callable) {
+			for (const rule of callable.rules ?? []) {
+				const size = sizeOf(inputOf(options, rule.name), rule.of);
+				if (size === void 0) continue;
+				const broken = brokenBound(rule, size);
+				if (!broken) continue;
+				const [bound, limit] = broken;
+				const held = rule.name === void 0 ? "The request body" : `\`${rule.name}\``;
+				const stated = rule.of === void 0 ? `is ${bound} ${limit}` : `takes ${bound} ${limit} ${limit === 1 ? COUNTED[rule.of] : rule.of}`;
+				throw refusedInput(held, stated, size);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/internal/feature/timeout.ts
+function describeTarget(request) {
+	const { method } = request.callable;
+	if (typeof request.address !== "string") return void 0;
+	const address = safeAddress(request.address);
+	return method ? `${method.toUpperCase()} "${address}"` : `"${address}"`;
+}
+function operationKey({ address, method }) {
+	return method ? `${method.toUpperCase()} ${address}` : address;
+}
+function resolveTimeout(base, request) {
+	const own = request.callable.timeout ?? base.ms ?? 6e4;
+	const option = request.options["timeout"];
+	const ms = typeof option === "function" ? option(operationKey(request.callable), own) ?? own : option ?? own;
+	if (ms === false) return void 0;
+	return ms > 0 && Number.isFinite(ms) ? ms : void 0;
+}
+function watchedReply(response, wait, done) {
+	const reader = response.body.getReader();
+	const body = new ReadableStream({
+		cancel(reason) {
+			done();
+			return reader.cancel(reason);
+		},
+		async pull(controller) {
+			const step = await wait(reader.read()).catch((error) => {
+				done();
+				reader.cancel(error).catch(done);
+				throw error;
+			});
+			if (step.done) {
+				done();
+				controller.close();
+			} else controller.enqueue(step.value);
+		}
+	});
+	return replyWith(body, response);
+}
+function timeoutFeature(options = {}) {
+	async function bounded(request, next, stream) {
+		const ms = resolveTimeout(options, request);
+		if (ms === void 0) return next(request);
+		const delay = Math.min(ms, TIMER_LIMIT);
+		let left = delay;
+		const caller = request.signal;
+		const controller = new AbortController();
+		const { signal } = controller;
+		function abortWithCaller() {
+			controller.abort(caller?.reason);
+		}
+		if (caller?.aborted) abortWithCaller();
+		caller?.addEventListener("abort", abortWithCaller, { once: true });
+		const abandoned = new Promise((_, reject) => {
+			function giveUp() {
+				reject(calledOffWith(signal.reason));
+			}
+			if (signal.aborted) giveUp();
+			else signal.addEventListener("abort", giveUp, { once: true });
+		});
+		abandoned.catch(() => {});
+		function expire() {
+			controller.abort(new TimeoutError(ms, void 0, describeTarget(request)));
+		}
+		async function wait(pending) {
+			const started = Date.now();
+			const timer = setTimeout(expire, left);
+			try {
+				return await Promise.race([pending, abandoned]);
+			} finally {
+				clearTimeout(timer);
+				left = stream ? delay : left - (Date.now() - started);
+			}
+		}
+		function done() {
+			caller?.removeEventListener("abort", abortWithCaller);
+		}
+		request.signal = signal;
+		const result = await wait(next(request)).catch((error) => {
+			done();
+			throw error;
+		}).finally(() => {
+			request.signal = caller;
+		});
+		const { response } = result;
+		if (response?.body && (stream || request.options.unread)) return {
+			...result,
+			response: watchedReply(response, wait, done)
+		};
+		done();
+		return result;
+	}
+	return {
+		name: "timeout",
+		onOpen: (request, next) => bounded(request, next, true),
+		onSend: (request, next) => bounded(request, next, false)
+	};
+}
+//#endregion
+//#region src/internal/transport/fetch.ts
+function checkAddress(address) {
+	let url;
+	try {
+		url = new URL(address, globalThis.location?.href);
+	} catch {
+		throw unsendableAddress(safeAddress(address), "is not a full address", "Start the base URL with `https://`.");
+	}
+	const shown = `${url.protocol}//${url.host}${url.pathname}`;
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw unsendableAddress(shown, `uses \`${url.protocol}\`, which fetch does not send`, "Start the base URL with `https://`.");
+	if (url.username || url.password) throw unsendableAddress(shown, "holds a user name or password, which fetch refuses", "Pass the credential as an option instead.");
+}
+const OWNED = [
+	"body",
+	"headers",
+	"method",
+	"signal"
+];
+function extraInit(request) {
+	const extra = request.options["fetchOptions"];
+	if (!extra) return void 0;
+	const rest = { ...extra };
+	for (const key of OWNED) delete rest[key];
+	return rest;
+}
+function toRequestInit(request) {
+	return {
+		...extraInit(request),
+		...request.body !== void 0 && { body: request.body },
+		...isStreamed(request.body) && { duplex: "half" },
+		headers: metadataHeaders(request.meta),
+		method: (request.callable.method ?? "get").toUpperCase(),
+		...request.signal !== void 0 && { signal: request.signal }
+	};
+}
+function createFetchTransport(fetchFn) {
+	function send(request) {
+		const call = request.options["fetch"] ?? fetchFn ?? globalThis.fetch;
+		if (call === globalThis.fetch) checkAddress(request.address);
+		return call(request.address, toRequestInit(request));
+	}
+	return {
+		name: "fetch",
+		unary: send
+	};
+}
+//#endregion
+//#region src/client.ts
+/** The version of this package. */
+const VERSION = "0.1.0";
+const declaredCredentials = { apiKey: { variable: "ELMO_API_KEY" } };
+let fetchTransportInstance;
+function fetchTransport() {
+	return fetchTransportInstance ??= createFetchTransport();
+}
+let clientInstance;
+function client() {
+	return clientInstance ??= createClient({
+		codecs: [jsonCodec],
+		credentials: declaredCredentials,
+		defaults: createConfig({
+			baseURL: "/api/v1",
+			headers: { "user-agent": `elmo-sdk/${VERSION} (typescript)` }
+		}),
+		env: {
+			baseURL: "ELMO_BASE_URL",
+			logLevel: "ELMO_LOG"
+		},
+		features: [
+			rulesFeature(),
+			authFeature({ schemes: declaredCredentials }),
+			retryFeature(),
+			loggerFeature(),
+			timeoutFeature({ ms: { overrides: [{
+				include: { openapi: { operations: ["GET /brands/{brandId}/opportunities", "POST /tools/analyze"] } },
+				ms: 6e5
+			}] } }),
+			interceptorsFeature(),
+			validateFeature()
+		],
+		guard: refuseBrowser,
+		protocols: { rest: {
+			binding: createRestBinding(simpleURL),
+			transport: fetchTransport()
+		} }
+	});
+}
+/**
+* A client for this API. Options given here apply to every call made
+* through it. Pass it to a call, or to an SDK, in place of the default one.
+*
+* @example
+* const elmo = createElmoClient({ apiKey: '…' });
+*/
+function createElmoClient(options) {
+	return clientFor(options, client());
+}
+/**
+* The Elmo API, as one object to call through.
+*
+* Pass `apiKey`, or set `ELMO_API_KEY` and pass nothing.
+*
+* Options given here apply to every call it makes.
+*
+* @example
+* const elmo = new Elmo();
+* await elmo.brands.list();
+*/
+var Elmo = class extends ElmoResource {
+	constructor(args) {
+		super(clientFor(args, client()));
+	}
+	_brands;
+	/** Manage brand records */
+	get brands() {
+		return this._brands ??= new Brands(this.client);
+	}
+	_competitors;
+	/** Manage brand competitors */
+	get competitors() {
+		return this._competitors ??= new Competitors(this.client);
+	}
+	_me;
+	/** What the calling key is and what it may reach */
+	get me() {
+		return this._me ??= new Me(this.client);
+	}
+	_models;
+	/** The answer engines this deployment can track */
+	get models() {
+		return this._models ??= new Models(this.client);
+	}
+	_organizations;
+	/** Organizations, their plan limits, and their usage */
+	get organizations() {
+		return this._organizations ??= new Organizations(this.client);
+	}
+	_prompts;
+	/** Manage brand prompts */
+	get prompts() {
+		return this._prompts ??= new Prompts(this.client);
+	}
+	_reports;
+	/** Generate and retrieve AI Share of Voice reports */
+	get reports() {
+		return this._reports ??= new Reports(this.client);
+	}
+	_tools;
+	/** One-shot helpers (e.g. brand analysis) that don't persist anything */
+	get tools() {
+		return this._tools ??= new Tools(this.client);
+	}
+	/** A failure the API answered with, so there is a status and a reply to read. */
+	static APIError = APIError;
+	/**
+	* 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.
+	*/
+	static AbortError = AbortError;
+	/** No usable credential reached the API: it was missing, unreadable, or rejected. */
+	static AuthenticationError = AuthenticationError;
+	/** The API could not read the request, so it did not act on it. */
+	static BadRequestError = BadRequestError;
+	/** The call collided with the resource's current state: a duplicate, or a concurrent change. */
+	static ConflictError = ConflictError;
+	/** A reply from the API that this SDK could not read, whatever its status. */
+	static DecodeError = DecodeError;
+	/** The base of every error this SDK throws, including one from a call that never arrived. */
+	static ElmoError = ElmoError;
+	/** The API failed after accepting the call. Every status from 500 up arrives as this. */
+	static InternalServerError = InternalServerError;
+	/** Thrown before the request goes out, when no credential satisfied the call. */
+	static MissingCredentialError = MissingCredentialError;
+	/** Nothing is at this address, or the credential may not see what is. */
+	static NotFoundError = NotFoundError;
+	/** The plan or the quota on this account does not cover the call. */
+	static PaymentRequiredError = PaymentRequiredError;
+	/** The credential was accepted, but it does not grant this call. */
+	static PermissionDeniedError = PermissionDeniedError;
+	/** Too many calls. {@link APIError.retryAfterMs} carries how long the API asked to wait. */
+	static RateLimitError = RateLimitError;
+	/**
+	* 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.
+	*/
+	static TimeoutError = TimeoutError;
+	/** Thrown when no whole answer arrived, so there is no reply to go on. */
+	static TransportError = TransportError;
+	/** The request was read, and its contents were rejected. */
+	static UnprocessableEntityError = UnprocessableEntityError;
+};
+//#endregion
+export { APIError, AbortError, AuthenticationError, BadRequestError, ConflictError, DecodeError, Elmo, ElmoError, InternalServerError, MissingCredentialError, NotFoundError, PaymentRequiredError, PermissionDeniedError, RateLimitError, TimeoutError, TransportError, UnprocessableEntityError, VERSION, createElmoClient };
+
+//# sourceMappingURL=index.mjs.map