@messagebird/sdk 0.3.0 → 0.4.2

package/dist/index.mjs

@@ -0,0 +1,3030 @@
+import { Webhook } from "standardwebhooks";
+//#region src/generated/core/bodySerializer.gen.ts
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+//#endregion
+//#region src/generated/core/serverSentEvents.gen.ts
+function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const requestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) request = await onRequest(url, requestInit);
+				const response = await (options.fetch ?? globalThis.fetch)(request);
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						buffer = buffer.replace(/\r\n?/g, "\n");
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+				await sleep(backoff);
+			}
+		}
+	};
+	return { stream: createStream() };
+}
+//#endregion
+//#region src/generated/core/pathSerializer.gen.ts
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+//#endregion
+//#region src/generated/core/utils.gen.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+function getValidRequestBody(options) {
+	const hasBody = options.body !== void 0;
+	if (hasBody && options.bodySerializer) {
+		if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
+}
+//#endregion
+//#region src/generated/core/auth.gen.ts
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+//#endregion
+//#region src/generated/client/utils.gen.ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			const options = parameters[name] || args;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...options.array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...options.object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved: options.allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+/**
+* Infers parseAs value from provided Content-Type header.
+*/
+const getParseAs = (contentType) => {
+	if (!contentType) return "stream";
+	const cleanContent = contentType.split(";")[0]?.trim();
+	if (!cleanContent) return;
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
+	if (cleanContent === "multipart/form-data") return "formData";
+	if ([
+		"application/",
+		"audio/",
+		"image/",
+		"video/"
+	].some((type) => cleanContent.startsWith(type))) return "blob";
+	if (cleanContent.startsWith("text/")) return "text";
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
+	return false;
+};
+async function setAuthParams(options) {
+	for (const auth of options.security ?? []) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			default:
+				options.headers.set(name, token);
+				break;
+		}
+	}
+}
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders$1(a.headers, b.headers);
+	return config;
+};
+const headersEntries = (headers) => {
+	const entries = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+const mergeHeaders$1 = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) continue;
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	fns = [];
+	clear() {
+		this.fns = [];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) this.fns[index] = null;
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this.fns[id] ? id : -1;
+		return this.fns.indexOf(id);
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+	use(fn) {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+//#endregion
+//#region src/generated/client/client.gen.ts
+const createClient = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders$1(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams(opts);
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body !== void 0 && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
+		if (opts.body === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
+		const resolvedOpts = opts;
+		return {
+			opts: resolvedOpts,
+			url: buildUrl(resolvedOpts)
+		};
+	};
+	const request = async (options) => {
+		const throwOnError = options.throwOnError ?? _config.throwOnError;
+		const responseStyle = options.responseStyle ?? _config.responseStyle;
+		let request;
+		let response;
+		try {
+			const { opts, url } = await beforeRequest(options);
+			const requestInit = {
+				redirect: "follow",
+				...opts,
+				body: getValidRequestBody(opts)
+			};
+			request = new Request(url, requestInit);
+			for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+			const _fetch = opts.fetch;
+			response = await _fetch(request);
+			for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request, opts);
+			const result = {
+				request,
+				response
+			};
+			if (response.ok) {
+				const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+				if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+					let emptyData;
+					switch (parseAs) {
+						case "arrayBuffer":
+						case "blob":
+						case "text":
+							emptyData = await response[parseAs]();
+							break;
+						case "formData":
+							emptyData = new FormData();
+							break;
+						case "stream":
+							emptyData = response.body;
+							break;
+						default:
+							emptyData = {};
+							break;
+					}
+					return opts.responseStyle === "data" ? emptyData : {
+						data: emptyData,
+						...result
+					};
+				}
+				let data;
+				switch (parseAs) {
+					case "arrayBuffer":
+					case "blob":
+					case "formData":
+					case "text":
+						data = await response[parseAs]();
+						break;
+					case "json": {
+						const text = await response.text();
+						data = text ? JSON.parse(text) : {};
+						break;
+					}
+					case "stream": return opts.responseStyle === "data" ? response.body : {
+						data: response.body,
+						...result
+					};
+				}
+				if (parseAs === "json") {
+					if (opts.responseValidator) await opts.responseValidator(data);
+					if (opts.responseTransformer) data = await opts.responseTransformer(data);
+				}
+				return opts.responseStyle === "data" ? data : {
+					data,
+					...result
+				};
+			}
+			const textError = await response.text();
+			let jsonError;
+			try {
+				jsonError = JSON.parse(textError);
+			} catch {}
+			throw jsonError ?? textError;
+		} catch (error) {
+			let finalError = error;
+			for (const fn of interceptors.error.fns) if (fn) finalError = await fn(finalError, response, request, options);
+			finalError = finalError || {};
+			if (throwOnError) throw finalError;
+			return responseStyle === "data" ? void 0 : {
+				error: finalError,
+				request,
+				response
+			};
+		}
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			method,
+			onRequest: async (url, init) => {
+				let request = new Request(url, init);
+				for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+				return request;
+			},
+			serializedBody: getValidRequestBody(opts),
+			url
+		});
+	};
+	const _buildUrl = (options) => buildUrl({
+		..._config,
+		...options
+	});
+	return {
+		buildUrl: _buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		interceptors,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE")
+		},
+		trace: makeMethodFn("TRACE")
+	};
+};
+//#endregion
+//#region src/region.ts
+const REGION_PATTERN = /^[a-z]{2}[0-9]+$/;
+/** Extracts the region code from a `bk_{region}_{token}` key, or undefined. */
+function regionFromApiKey(apiKey) {
+	const [prefix, region, token] = apiKey.split("_");
+	if (prefix !== "bk" || !region || !token) return void 0;
+	return REGION_PATTERN.test(region) ? region : void 0;
+}
+function baseUrlForRegion(region) {
+	return `https://${region}.platform.bird.com`;
+}
+//#endregion
+//#region src/caller-rules.gen.ts
+const callerRules = [
+	{
+		env: "CLAUDECODE",
+		name: "claude-code"
+	},
+	{
+		env: "CODEX_CI",
+		name: "codex"
+	},
+	{
+		env: "GEMINI_CLI",
+		name: "gemini"
+	},
+	{
+		env: "QWEN_CODE",
+		name: "qwen"
+	},
+	{
+		env: "PI_CODING_AGENT",
+		name: "pi"
+	},
+	{
+		env: "OPENCODE",
+		name: "opencode"
+	},
+	{
+		env: "CLINE_ACTIVE",
+		name: "cline"
+	},
+	{
+		env: "ROO_ACTIVE",
+		name: "roo"
+	},
+	{
+		env: "CURSOR_TRACE_ID",
+		name: "cursor"
+	},
+	{
+		env: "CURSOR_AGENT",
+		name: "cursor"
+	},
+	{
+		env: "ANTIGRAVITY_AGENT",
+		name: "antigravity"
+	},
+	{
+		env: "AUGMENT_AGENT",
+		name: "augment"
+	},
+	{
+		env: "AGENT",
+		passthrough: true
+	},
+	{
+		env: "AI_AGENT",
+		passthrough: true
+	},
+	{
+		env: "REPL_ID",
+		name: "replit"
+	},
+	{
+		env: "CI",
+		name: "ci"
+	},
+	{
+		env: "GITHUB_ACTIONS",
+		name: "ci"
+	},
+	{
+		env: "TERM_PROGRAM",
+		equals: "zed",
+		name: "zed"
+	},
+	{
+		env: "ZED_TERM",
+		name: "zed"
+	},
+	{
+		env: "TERM_PROGRAM",
+		equals: "kiro",
+		name: "kiro"
+	},
+	{
+		env: "TERM_PROGRAM",
+		equals: "WarpTerminal",
+		name: "warp"
+	},
+	{
+		env: "TERMINAL_EMULATOR",
+		equals: "JetBrains-JediTerm",
+		name: "jetbrains"
+	},
+	{
+		env: "__CFBundleIdentifier",
+		equals: "com.exafunction.windsurf",
+		name: "windsurf"
+	},
+	{
+		env: "TERM_PROGRAM",
+		equals: "vscode",
+		name: "vscode"
+	}
+];
+const callerBooleanishSkip = /* @__PURE__ */ new Set([
+	"1",
+	"0",
+	"true",
+	"false",
+	"yes",
+	"no",
+	"on",
+	"off"
+]);
+const callerDefault = "shell";
+//#endregion
+//#region src/detect-caller.ts
+/**
+* Infers the environment driving the SDK for the `Bird-Caller` usage-telemetry
+* label by walking the generated rules in order (single source of truth:
+* `clients/caller-detection.yaml`, shared with the CLI and the other SDKs).
+* Best-effort and non-authoritative — it only labels traffic, never gates
+* behavior.
+*
+* Edge-safe: `process` is read only through a `typeof`-style `globalThis` guard,
+* so on a browser (no `process.env`) it returns `""` and the client sends no
+* `Bird-Caller` header. `env` is injected in tests.
+*/
+function detectCaller(env) {
+	let source = env;
+	if (source === void 0) {
+		const proc = globalThis.process;
+		if (proc?.versions?.node === void 0) return "";
+		source = proc.env ?? {};
+	}
+	for (const rule of callerRules) {
+		const value = source[rule.env];
+		if (value === void 0 || value === "" || rule.equals !== void 0 && value !== rule.equals) continue;
+		if (!rule.passthrough) return rule.name;
+		const sanitized = sanitizeCaller(value);
+		if (sanitized) return sanitized;
+	}
+	return callerDefault;
+}
+function sanitizeCaller(value) {
+	const s = value.trim().toLowerCase();
+	if (s === "" || s.length > 32 || callerBooleanishSkip.has(s)) return "";
+	return /^[a-z0-9._-]+$/.test(s) ? s : "";
+}
+//#endregion
+//#region src/errors.ts
+/** Root of the hierarchy. Catch this to catch anything the SDK throws. */
+var BirdError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "BirdError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** Network-level failure with no HTTP response (DNS, refused, socket hangup). */
+var BirdConnectionError = class extends BirdError {
+	constructor(message) {
+		super(message);
+		this.name = "BirdConnectionError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** A single attempt exceeded its timeout. Retryable. */
+var BirdTimeoutError = class extends BirdError {
+	timeoutMs;
+	constructor(message, timeoutMs) {
+		super(message);
+		this.name = "BirdTimeoutError";
+		this.timeoutMs = timeoutMs;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** A webhook payload failed signature verification (bad signature, stale timestamp, malformed headers). */
+var BirdWebhookVerificationError = class extends BirdError {
+	constructor(message) {
+		super(message);
+		this.name = "BirdWebhookVerificationError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** The server returned an error body. Base for every `type`-specific class. */
+var BirdAPIError = class extends BirdError {
+	statusCode;
+	code;
+	type;
+	errorName;
+	docUrl;
+	requestId;
+	param;
+	vendorCode;
+	remediation;
+	next;
+	constructor(fields) {
+		super(fields.message);
+		this.name = "BirdAPIError";
+		this.statusCode = fields.statusCode;
+		this.code = fields.code;
+		this.type = fields.type;
+		this.errorName = fields.errorName;
+		this.docUrl = fields.docUrl;
+		this.requestId = fields.requestId;
+		this.param = fields.param;
+		this.vendorCode = fields.vendorCode;
+		this.remediation = fields.remediation;
+		this.next = fields.next;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 401 — authentication failed or missing. */
+var BirdAuthError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdAuthError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 403 — authenticated but not allowed. */
+var BirdPermissionError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdPermissionError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 404 — resource does not exist. */
+var BirdNotFoundError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdNotFoundError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 409 — semantic conflict (e.g. a unique value already taken). */
+var BirdConflictError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdConflictError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 400 — malformed request. */
+var BirdBadRequestError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdBadRequestError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 402 — billing/balance problem. */
+var BirdBillingError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdBillingError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 412/428 — a precondition was not met. */
+var BirdPreconditionError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdPreconditionError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 413 — request body too large. */
+var BirdPayloadTooLargeError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdPayloadTooLargeError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 500 — unexpected server error. */
+var BirdInternalError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdInternalError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 501 — endpoint not implemented. */
+var BirdNotImplementedError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdNotImplementedError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 421 — request reached the wrong region (ADR-0036). */
+var BirdMisdirectedError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdMisdirectedError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 503 — service temporarily unavailable. */
+var BirdServiceUnavailableError = class extends BirdAPIError {
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdServiceUnavailableError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 422 — field validation failed; `details` carries the per-field errors. */
+var BirdValidationError = class extends BirdAPIError {
+	details;
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdValidationError";
+		this.details = fields.details;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 429 — rate limited; `retryAfter` is the server-advised wait in seconds. */
+var BirdRateLimitError = class extends BirdAPIError {
+	retryAfter;
+	constructor(fields) {
+		super(fields);
+		this.name = "BirdRateLimitError";
+		this.retryAfter = fields.retryAfter;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/**
+* Parse `Retry-After` (delta-seconds or HTTP-date) into whole seconds. A
+* negative or unparseable value yields `undefined` — a negative wait is
+* meaningless, so both the user-facing `retryAfter` and the retry loop treat it
+* as "no server advice". The single Retry-After parser; `retryDelay` builds on it.
+*/
+function parseRetryAfter(headers) {
+	const header = headers?.get("Retry-After");
+	if (!header) return void 0;
+	const seconds = Number(header);
+	const value = Number.isFinite(seconds) ? seconds : (Date.parse(header) - Date.now()) / 1e3;
+	return Number.isFinite(value) && value >= 0 ? Math.round(value) : void 0;
+}
+function inferType(status) {
+	switch (status) {
+		case 400: return "bad_request_error";
+		case 401: return "auth_error";
+		case 402: return "billing_error";
+		case 403: return "permission_error";
+		case 404: return "not_found_error";
+		case 409: return "conflict_error";
+		case 412:
+		case 428: return "precondition_error";
+		case 413: return "payload_too_large_error";
+		case 421: return "misdirected_error";
+		case 422: return "validation_error";
+		case 429: return "rate_limit_error";
+		case 501: return "not_implemented_error";
+		case 503: return "service_unavailable_error";
+		default: return status >= 500 ? "internal_error" : "bad_request_error";
+	}
+}
+/**
+* Map a non-2xx response to the right `BirdAPIError` subclass. The single place
+* the SDK turns a wire error into a thrown error.
+*/
+function mapResponseToError(status, body, headers) {
+	const raw = body ?? {};
+	const b = raw.error ?? raw ?? {};
+	const fields = {
+		statusCode: status,
+		code: b.code ?? "unknown",
+		type: b.type ?? inferType(status),
+		errorName: b.name ?? "",
+		message: b.message ?? `Request failed with status ${status}`,
+		docUrl: b.doc_url ?? "",
+		requestId: b.request_id ?? headers?.get("X-Request-Id") ?? "",
+		param: b.param,
+		vendorCode: b.vendor_code,
+		remediation: b.remediation,
+		next: b.next ?? []
+	};
+	switch (fields.type) {
+		case "auth_error": return new BirdAuthError(fields);
+		case "permission_error": return new BirdPermissionError(fields);
+		case "not_found_error": return new BirdNotFoundError(fields);
+		case "conflict_error": return new BirdConflictError(fields);
+		case "bad_request_error": return new BirdBadRequestError(fields);
+		case "billing_error": return new BirdBillingError(fields);
+		case "precondition_error": return new BirdPreconditionError(fields);
+		case "payload_too_large_error": return new BirdPayloadTooLargeError(fields);
+		case "internal_error": return new BirdInternalError(fields);
+		case "not_implemented_error": return new BirdNotImplementedError(fields);
+		case "misdirected_error": return new BirdMisdirectedError(fields);
+		case "service_unavailable_error": return new BirdServiceUnavailableError(fields);
+		case "rate_limit_error": return new BirdRateLimitError({
+			...fields,
+			retryAfter: parseRetryAfter(headers)
+		});
+		case "validation_error": return new BirdValidationError({
+			...fields,
+			details: b.details ?? []
+		});
+		default: return new BirdAPIError(fields);
+	}
+}
+//#endregion
+//#region src/core/http.ts
+const BACKOFF_BASE_MS = 500;
+const BACKOFF_CAP_MS = 8e3;
+const RETRY_AFTER_CAP_MS = 6e4;
+var BirdHTTPClient = class {
+	defaults;
+	constructor(defaults) {
+		this.defaults = defaults;
+	}
+	/**
+	* Run a generated hey-api SDK call through the request lifecycle.
+	*
+	* @param call  Invokes the SDK function; receives the per-attempt signal and
+	*              the idempotency key to set as a header.
+	* @returns the parsed body plus transport metadata.
+	* @throws  a `BirdError` subclass on terminal failure; the native
+	*          `AbortError` if the caller's signal aborts.
+	*/
+	async request(call, options) {
+		const maxRetries = options.maxRetries ?? this.defaults.maxRetries;
+		const timeout = options.timeout ?? this.defaults.timeout;
+		const idempotencyKey = options.idempotencyKey ?? (isMutation(options.method) ? crypto.randomUUID() : void 0);
+		for (let attempt = 0;; attempt++) {
+			throwIfAborted(options.signal);
+			const retryOrThrow = async (terminal) => {
+				if (attempt >= maxRetries) throw terminal();
+				await sleep(backoffDelay(attempt), options.signal);
+			};
+			const timeoutSignal = AbortSignal.timeout(timeout);
+			const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+			let outcome;
+			try {
+				outcome = await call({
+					signal,
+					idempotencyKey
+				});
+			} catch (err) {
+				throwIfAborted(options.signal);
+				await retryOrThrow(() => timeoutSignal.aborted ? new BirdTimeoutError(`Request timed out after ${timeout}ms`, timeout) : new BirdConnectionError(errorMessage(err)));
+				continue;
+			}
+			const res = outcome.response;
+			if (!res) {
+				await retryOrThrow(() => new BirdConnectionError("No response received from the server"));
+				continue;
+			}
+			if (res.ok) return {
+				data: outcome.data,
+				response: toBirdResponse(res)
+			};
+			if (!isRetryableStatus(res.status) || attempt >= maxRetries) throw mapResponseToError(res.status, outcome.error, res.headers);
+			await sleep(retryDelay(attempt, res.headers), options.signal);
+		}
+	}
+};
+function isMutation(method) {
+	return [
+		"POST",
+		"PATCH",
+		"DELETE"
+	].includes(method.toUpperCase());
+}
+function isRetryableStatus(status) {
+	return [
+		408,
+		429,
+		500,
+		502,
+		503,
+		504
+	].includes(status);
+}
+/** Full-jitter exponential backoff: random in [0, min(cap, base·2^attempt)). */
+function backoffDelay(attempt) {
+	const ceiling = Math.min(BACKOFF_CAP_MS, BACKOFF_BASE_MS * 2 ** attempt);
+	return Math.random() * ceiling;
+}
+/** Honor Retry-After on a retryable response, else fall back to backoff. */
+function retryDelay(attempt, headers) {
+	const seconds = parseRetryAfter(headers);
+	return seconds === void 0 ? backoffDelay(attempt) : Math.min(seconds * 1e3, RETRY_AFTER_CAP_MS);
+}
+function toBirdResponse(res) {
+	return {
+		status: res.status,
+		headers: res.headers,
+		requestId: res.headers.get("X-Request-Id") ?? ""
+	};
+}
+function abortReason(signal) {
+	return signal?.reason ?? new DOMException("Aborted", "AbortError");
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw abortReason(signal);
+}
+/** Sleep, rejecting immediately if the caller's signal aborts. */
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(abortReason(signal));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(abortReason(signal));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function errorMessage(err) {
+	if (err instanceof Error) return err.message;
+	return String(err);
+}
+//#endregion
+//#region src/core/result.ts
+function basePromise(inner) {
+	const promise = inner.then((r) => r.data);
+	promise.catch(() => {});
+	promise.withResponse = () => inner;
+	promise.safe = () => toSafe(inner);
+	return promise;
+}
+function apiPromise(inner) {
+	return basePromise(inner);
+}
+function paginate(fetchPage) {
+	const first = fetchPage();
+	const promise = basePromise(first);
+	promise[Symbol.asyncIterator] = async function* () {
+		let result = await first;
+		for (;;) {
+			for (const item of result.data.data) yield item;
+			if (result.data.next_cursor == null) return;
+			result = await fetchPage(result.data.next_cursor);
+		}
+	};
+	return promise;
+}
+function toSafe(inner) {
+	return inner.then(({ data, response }) => ({
+		data,
+		error: null,
+		response
+	}), (error) => {
+		if (error instanceof BirdError) return {
+			data: null,
+			error,
+			response: null
+		};
+		throw error;
+	});
+}
+//#endregion
+//#region src/generated/client.gen.ts
+const client = createClient(createConfig());
+//#endregion
+//#region src/generated/sdk.gen.ts
+/**
+* List messages
+*
+* Returns a paginated list of email messages in the workspace, newest first.
+*/
+const listEmailMessages = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/messages",
+	...options
+});
+/**
+* Send a message
+*
+* Sends an email to the recipients you list explicitly in `to`/`cc`/`bcc`. Use this for transactional sends (receipts, password resets, alerts) and for marketing sends where you have the recipient addresses on hand. For sends targeting a stored audience by reference, use POST /v1/email/broadcasts. The `category` field controls suppression policy independently — set it to `marketing` when sending marketing content from this endpoint. The 202 response is returned only after the message is safely accepted for delivery. If the sender domain is not verified, or all recipients are suppressed, the request fails immediately with a 422 — it is never accepted and then silently dropped. Other field-level validation failures also return 422.
+* Recipient addresses on reserved testing domains are rejected with a 422 RecipientDomainNotAllowed error. This covers @example.com, @example.net, @example.org, @example.edu, @test.com, and any address under the reserved .test, .example, .invalid, or .localhost top-level domains. These placeholder domains cannot receive mail, and the resulting bounces would hurt your sender reputation — use a real recipient address instead.
+* During onboarding, you can send without verifying a domain: use any sender address on the shared onboarding domain (for example onboarding@messagebird.dev). Such sends skip the sender-domain verification check, can only go to verified members of your workspace (other recipients are rejected with a 422 OnboardingRecipientNotAllowed error), and are subject to a daily recipient limit per organization (429 OnboardingSendLimitExceeded once exhausted).
+*
+*/
+const createEmailMessage = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/messages",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Send a batch of messages
+*
+* Accepts up to 100 independent email messages and queues them for delivery. All items are validated before any are queued — if one fails validation, the entire batch is rejected. Field-level validation failures and business-rule failures (such as domain_not_verified or all_recipients_suppressed) both return 422. Attachments are allowed per message. Each message must stay within the 20 MB estimated generated message-size cap. The serialized JSON request body for the batch has a hard 20 MB cap.
+*
+*/
+const createEmailMessageBatch = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/batches",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get a message
+*
+* Returns a single email message object with aggregate delivery status and counts. Message body (html, text) is not returned — it is not stored after delivery.
+*
+*/
+const getEmailMessage = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/messages/{message_id}",
+	...options
+});
+/**
+* List contacts
+*
+* Returns a paginated list of contacts in the workspace, newest first. Look up a single contact by its exact `email` or `external_id`, or search by email substring with `search`.
+*
+*/
+const listContacts = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contacts",
+	...options
+});
+/**
+* Create a contact
+*
+* Creates a contact in the workspace. Contacts are unique by email address; creating a second contact with the same email returns a conflict error. The same applies to `external_id` — a value already used by another contact returns a conflict error. Custom values in `data` must use property keys you created via the contact properties API, with values matching each property's declared type.
+*
+*/
+const createContact = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contacts",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Create or update contacts in bulk
+*
+* Creates or updates up to 1,000 contacts in one request, matched by email address (trimmed and lowercased before matching). Existing contacts are updated with the supplied fields; new ones are created. Optionally adds every contact in the request to one or more audiences. Results are returned per contact, in submission order — a failed entry does not abort the rest of the request.
+*
+*/
+const createContactBatch = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contacts/batch",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a contact
+*
+* Deletes a contact and removes it from every audience it belongs to. Suppression records for the address are not affected — an unsubscribed or bounced address stays suppressed even after the contact is deleted.
+*
+*/
+const deleteContact = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contacts/{contact_id}",
+	...options
+});
+/**
+* Get a contact
+*
+* Returns a single contact by ID.
+*/
+const getContact = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contacts/{contact_id}",
+	...options
+});
+/**
+* Update a contact
+*
+* Updates a contact. Supplied fields are changed; omitted fields are left unchanged. Custom values in `data` are merged — keys you supply are set, keys set to null are removed, and keys you omit are unchanged. Changing the email address or `external_id` to a value already used by another contact returns a conflict error.
+*
+*/
+const updateContact = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contacts/{contact_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List contact properties
+*
+* Returns a paginated list of the workspace's contact properties.
+*/
+const listContactProperties = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contact-properties",
+	...options
+});
+/**
+* Create a contact property
+*
+* Defines a custom property that contacts in the workspace can carry. The key becomes available in contact `data` and as a template variable in broadcasts. Keys are unique within the workspace; the key and type cannot be changed after creation.
+*
+*/
+const createContactProperty = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contact-properties",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get a contact property
+*
+* Returns a single contact property by ID.
+*/
+const getContactProperty = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contact-properties/{property_id}",
+	...options
+});
+/**
+* Update a contact property
+*
+* Updates a contact property's fallback value. The key and type cannot be changed after creation — create a new property instead.
+*
+*/
+const updateContactProperty = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contact-properties/{property_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Archive a contact property
+*
+* Archives a contact property. The key stops being accepted in new contact writes and stops rendering in templates, but every value already stored on your contacts is preserved and still returned when you read a contact. The key stays reserved, so it cannot be re-created with a different type. Returns 409 if the property is already archived. Reverse it with unarchive.
+*
+*/
+const archiveContactProperty = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contact-properties/{property_id}/archive",
+	...options
+});
+/**
+* Unarchive a contact property
+*
+* Reactivates an archived contact property. The key is accepted in contact writes and renders in templates again; stored values were never removed, so they are unchanged. Returns 409 if the property is not archived.
+*
+*/
+const unarchiveContactProperty = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/contact-properties/{property_id}/unarchive",
+	...options
+});
+/**
+* List audiences
+*
+* Returns a paginated list of audiences in the workspace, newest first.
+*/
+const listAudiences = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/audiences",
+	...options
+});
+/**
+* Create an audience
+*
+* Creates an audience in the workspace. Static audiences start empty — add contacts via the audience contacts endpoint or the bulk contact upsert.
+*
+*/
+const createAudience = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/audiences",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete an audience
+*
+* Deletes an audience and its memberships. Contacts themselves are not deleted. An audience cannot be deleted while a broadcast targeting it is scheduled, accepted, sending, or canceling — cancel that broadcast first.
+*
+*/
+const deleteAudience = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/audiences/{audience_id}",
+	...options
+});
+/**
+* Get an audience
+*
+* Returns a single audience by ID.
+*/
+const getAudience = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/audiences/{audience_id}",
+	...options
+});
+/**
+* Update an audience
+*
+* Updates an audience's name or description.
+*/
+const updateAudience = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/audiences/{audience_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List an audience's contacts
+*
+* Lists the contacts in a static audience as a cursor page, ordered by the time each contact joined the audience, most recent first. Each entry is the contact together with the time it joined.
+*
+*/
+const listAudienceContacts = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/audiences/{audience_id}/contacts",
+	...options
+});
+/**
+* Add contacts to an audience
+*
+* Adds up to 1,000 contacts to a static audience. Contacts that are already members are left in place. If any contact ID does not exist, the whole request fails and no contacts are added.
+*
+*/
+const assignAudienceContacts = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/audiences/{audience_id}/contacts",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Remove contacts from an audience
+*
+* Removes up to 1,000 contacts from a static audience. Contacts that are not members are skipped. If any contact ID does not exist, the whole request fails and no contacts are removed. The contacts themselves are not deleted and remain members of any other audiences.
+*
+*/
+const unassignAudienceContacts = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/audiences/{audience_id}/contacts/remove",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Remove a contact from an audience
+*
+* Removes a contact's membership in an audience. The contact itself is not deleted and remains a member of any other audiences. Removing a contact that is not a member of the audience succeeds with no effect (204); an unknown audience or contact returns a not-found error.
+*
+*/
+const unassignAudienceContact = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/audiences/{audience_id}/contacts/{contact_id}",
+	...options
+});
+/**
+* List SMS messages
+*
+* Returns a paginated list of SMS messages in the workspace, newest first.
+*/
+const listSmsMessages = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/sms/messages",
+	...options
+});
+/**
+* Send an SMS message
+*
+* Sends a single SMS message to one recipient. The 202 response is returned only after the message is durably accepted for delivery; actual delivery happens asynchronously, and you track it with the get-message and list-events endpoints or with webhooks. `category` is required and controls opt-out (STOP) policy, quiet hours, and per-country compliance. A body exceeding the 12-segment cap is rejected with a 422, as are field-level validation failures and sends that cannot be afforded by the workspace balance.
+*
+*/
+const createSmsMessage = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/sms/messages",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Send a batch of SMS messages
+*
+* Accepts up to 100 independent SMS messages and queues them for delivery. Each message is an independent send with its own ID, status, and cost. All items are validated before any are queued — if one fails validation, the entire batch is rejected. Field-level validation failures, the 12-segment body cap, and insufficient workspace balance all return 422 (or 402 for balance).
+*
+*/
+const createSmsMessageBatch = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/sms/batches",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get an SMS message
+*
+* Returns a single SMS message with its current status, segment breakdown, cost, and failure detail if it failed.
+*/
+const getSmsMessage = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/sms/messages/{message_id}",
+	...options
+});
+/**
+* List SMS templates
+*
+* Returns the SMS templates available to your workspace, including Bird's built-in templates. Filter by scope, category, or language.
+*
+*/
+const listSmsTemplates = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/sms/templates",
+	...options
+});
+/**
+* Get an SMS template
+*
+* Returns a single SMS template by its name or id.
+*/
+const getSmsTemplate = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/sms/templates/{template_ref}",
+	...options
+});
+/**
+* List email templates
+*
+* Returns a paginated list of the workspace's email templates, newest first. Filter by category, source, or a case-insensitive search that matches the template's name or description.
+*
+*/
+const listEmailTemplates = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/templates",
+	...options
+});
+/**
+* Create an email template
+*
+* Creates a template and its initial editable draft. The body carries the template's name, category, authoring format (`source`), and the draft's content (`subject`, `html`, `text`). A name already used in the workspace returns a conflict.
+*
+*/
+const createEmailTemplate = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/templates",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete an email template
+*
+* Deletes the template and all its versions. The name becomes available for reuse within the workspace.
+*
+*/
+const deleteEmailTemplate = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/templates/{template_id}",
+	...options
+});
+/**
+* Get an email template
+*
+* Returns a single email template with its current draft content (subject, HTML, and plain text), the draft revision, and its draft and published version ids.
+*
+*/
+const getEmailTemplate = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/templates/{template_id}",
+	...options
+});
+/**
+* Update an email template
+*
+* Updates a template's metadata and its draft content. Only the fields you send are changed. Send the draft `revision` you last read; if it is stale (someone else edited the draft first) the request returns a conflict so you can reload and retry.
+*
+*/
+const updateEmailTemplate = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/templates/{template_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List email template versions
+*
+* Returns every version of the template — the current draft plus all published versions — newest first.
+*
+*/
+const listEmailTemplateVersions = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/templates/{template_id}/versions",
+	...options
+});
+/**
+* Get an email template version
+*
+* Returns a single version of an email template.
+*/
+const getEmailTemplateVersion = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/templates/{template_id}/versions/{version_id}",
+	...options
+});
+/**
+* Publish an email template
+*
+* Publishes the template's current draft as a new immutable, numbered version and makes it the live version used by sends. The draft remains editable for future changes. The draft must have a subject and a body; an empty draft is rejected.
+*
+*/
+const publishEmailTemplate = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/templates/{template_id}/publish",
+	...options
+});
+//#endregion
+//#region src/resources/base.ts
+var Resource = class {
+	core;
+	client;
+	constructor(core, client) {
+		this.core = core;
+		this.client = client;
+	}
+	/** Run a single typed call through the lifecycle. */
+	call(method, options, invoke) {
+		return apiPromise(this.core.request((ctx) => invoke(callContext(ctx, options)), lifecycle(method, options)));
+	}
+	/** Run a cursor-paginated list through the lifecycle (each page retried independently). */
+	paginated(method, options, invoke) {
+		return paginate((cursor) => this.core.request((ctx) => invoke(callContext(ctx, options), cursor), lifecycle(method, options)));
+	}
+};
+function callContext(ctx, options) {
+	return {
+		signal: ctx.signal,
+		headers: mergeHeaders(ctx.idempotencyKey, options?.headers)
+	};
+}
+function lifecycle(method, options) {
+	return {
+		method,
+		idempotencyKey: options?.idempotencyKey,
+		signal: options?.signal,
+		timeout: options?.timeout,
+		maxRetries: options?.maxRetries
+	};
+}
+function mergeHeaders(idempotencyKey, extra) {
+	return {
+		...extra,
+		...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}
+	};
+}
+//#endregion
+//#region src/resources/email.ts
+var EmailResource = class extends Resource {
+	#defaults;
+	constructor(core, client, defaults) {
+		super(core, client);
+		this.#defaults = defaults;
+	}
+	/**
+	* Send an email message. Resolves once the message is accepted for delivery
+	* (the API's 202). Throws on failure — a 422 (unverified sender, all
+	* recipients suppressed, validation) is a `BirdValidationError`. Fields set as
+	* channel defaults may be omitted (per-send value wins).
+	*
+	* @example Send a message
+	* const msg = await bird.email.send({
+	*   from: { email: "onboarding@messagebird.dev", name: "Bird" },
+	*   to: ["delivered@messagebird.dev"],
+	*   subject: "Hello from Bird",
+	*   html: "<p>My first Bird email.</p>",
+	* });
+	* console.log(msg.id, msg.status); // "em_…", "accepted"
+	*
+	* @example A richer send — cc/bcc, reply-to, tags, metadata, click-tracking off, and an idempotency key (safe to retry; the server dedupes)
+	* await bird.email.send(
+	*   {
+	*     from: "hello@acme.com",
+	*     to: ["a@example.com", "b@example.com"],
+	*     cc: ["manager@example.com"],
+	*     reply_to: ["support@acme.com"],
+	*     subject: "Your March invoice",
+	*     html: "<p>Attached.</p>",
+	*     tags: [{ name: "category", value: "billing" }],
+	*     metadata: { invoice_id: "inv_123" },
+	*     track_clicks: false,
+	*   },
+	*   { idempotencyKey: "invoice-march/cust_1" },
+	* );
+	*
+	* @example Branch on the typed error hierarchy
+	* import { BirdRateLimitError, BirdValidationError, BirdAPIError } from "@messagebird/sdk";
+	*
+	* try {
+	*   await bird.email.send({
+	*     from: { email: "onboarding@messagebird.dev", name: "Bird" },
+	*     to: ["delivered@messagebird.dev"],
+	*     subject: "Hello from Bird",
+	*     html: "<p>My first Bird email.</p>",
+	*   });
+	* } catch (err) {
+	*   if (err instanceof BirdRateLimitError) console.log(`rate limited — retry in ${err.retryAfter}s`);
+	*   else if (err instanceof BirdValidationError) console.error(err.details);
+	*   else if (err instanceof BirdAPIError) console.error(err.code, err.requestId);
+	*   else throw err;
+	* }
+	*
+	* @example Errors as values with `.safe()`
+	* const { data, error } = await bird.email
+	*   .send({
+	*     from: { email: "onboarding@messagebird.dev", name: "Bird" },
+	*     to: ["delivered@messagebird.dev"],
+	*     subject: "Hello from Bird",
+	*     html: "<p>My first Bird email.</p>",
+	*   })
+	*   .safe();
+	* if (error) console.error(error.message);
+	* else console.log(data.id);
+	*/
+	send(params, options) {
+		const body = {
+			...this.#defaults,
+			...params
+		};
+		return this.call("POST", options, ({ signal, headers }) => createEmailMessage({
+			client: this.client,
+			body,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Send a batch of up to 100 independent email messages in one request. The
+	* batch is validated as a unit — if any item fails validation (unverified
+	* sender, all recipients suppressed, field-level errors) the whole batch is
+	* rejected with a `BirdValidationError` and nothing is queued. Resolves with
+	* one accepted item per submitted message, in submission order, once the batch
+	* is accepted (the API's 202). Channel defaults are applied per item.
+	*
+	* @example Send a batch of messages
+	* const batch = await bird.email.sendBatch([
+	*   {
+	*     from: { email: "onboarding@messagebird.dev", name: "Bird" },
+	*     to: ["alice@example.com"],
+	*     subject: "Your receipt",
+	*     html: "<p>Thanks, Alice.</p>",
+	*   },
+	*   {
+	*     from: { email: "onboarding@messagebird.dev", name: "Bird" },
+	*     to: ["bob@example.com"],
+	*     subject: "Your receipt",
+	*     html: "<p>Thanks, Bob.</p>",
+	*   },
+	* ]);
+	* for (const item of batch.data) console.log(item.id, item.status);
+	*/
+	sendBatch(params, options) {
+		const body = params.map((item) => ({
+			...this.#defaults,
+			...item
+		}));
+		return this.call("POST", options, ({ signal, headers }) => createEmailMessageBatch({
+			client: this.client,
+			body,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Fetch a message with aggregate delivery status.
+	*
+	* @example
+	* const msg = await bird.email.get("em_abc123");
+	* msg.status; // "accepted" | "processed" | "delivered" | "bounced" | …
+	* msg.delivered_count;
+	* msg.bounced_count;
+	*/
+	get(messageId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getEmailMessage({
+			client: this.client,
+			path: { message_id: messageId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* List messages, newest first. `await` resolves the first page; `for await`
+	* walks every message across all pages.
+	*
+	* @example Iterate every message, or take one page
+	* for await (const message of bird.email.list({ status: "bounced" })) {
+	*   console.log(message.id);
+	* }
+	* const page = await bird.email.list({ limit: 50 }); // page.data, page.next_cursor
+	*/
+	list(query, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listEmailMessages({
+			client: this.client,
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+};
+//#endregion
+//#region src/resources/audiences.ts
+var AudiencesResource = class extends Resource {
+	/**
+	* Create an audience.
+	*
+	* @example Create an audience
+	* const audience = await bird.audiences.create({ name: "Newsletter subscribers" });
+	* console.log(audience.id); // "aud_…"
+	*/
+	create(params, options) {
+		return this.call("POST", options, ({ signal, headers }) => createAudience({
+			client: this.client,
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* List the workspace's audiences, newest first. `await` resolves the first
+	* page; `for await` walks every audience across pages.
+	*
+	* @example
+	* for await (const audience of bird.audiences.list()) {
+	*   console.log(audience.id, audience.name);
+	* }
+	*/
+	list(query, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listAudiences({
+			client: this.client,
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Fetch a single audience by id.
+	*
+	* @example
+	* const audience = await bird.audiences.get("aud_01krdgeqcxet5s7t44vh8rt9mg");
+	*/
+	get(audienceId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getAudience({
+			client: this.client,
+			path: { audience_id: audienceId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Update an audience. Only the fields you send change.
+	*
+	* @example
+	* await bird.audiences.update("aud_01krdgeqcxet5s7t44vh8rt9mg", { name: "Renamed" });
+	*/
+	update(audienceId, params, options) {
+		return this.call("PATCH", options, ({ signal, headers }) => updateAudience({
+			client: this.client,
+			path: { audience_id: audienceId },
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Delete an audience. Its contacts are unaffected.
+	*
+	* @example
+	* await bird.audiences.delete("aud_01krdgeqcxet5s7t44vh8rt9mg");
+	*/
+	delete(audienceId, options) {
+		return this.call("DELETE", options, ({ signal, headers }) => deleteAudience({
+			client: this.client,
+			path: { audience_id: audienceId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* List the contacts in an audience, newest first. `await` resolves the first
+	* page; `for await` walks every member across pages.
+	*
+	* @example
+	* for await (const member of bird.audiences.listContacts("aud_01krdgeqcxet5s7t44vh8rt9mg")) {
+	*   console.log(member.contact.id, member.joined_at);
+	* }
+	*/
+	listContacts(audienceId, query, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listAudienceContacts({
+			client: this.client,
+			path: { audience_id: audienceId },
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Add contacts to an audience by id.
+	*
+	* @example
+	* await bird.audiences.addContacts("aud_01krdgeqcxet5s7t44vh8rt9mg", {
+	*   contact_ids: ["con_1", "con_2"],
+	* });
+	*/
+	addContacts(audienceId, params, options) {
+		return this.call("POST", options, ({ signal, headers }) => assignAudienceContacts({
+			client: this.client,
+			path: { audience_id: audienceId },
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Remove a set of contacts from an audience.
+	*
+	* @example
+	* await bird.audiences.removeContacts("aud_01krdgeqcxet5s7t44vh8rt9mg", {
+	*   contact_ids: ["con_1", "con_2"],
+	* });
+	*/
+	removeContacts(audienceId, params, options) {
+		return this.call("POST", options, ({ signal, headers }) => unassignAudienceContacts({
+			client: this.client,
+			path: { audience_id: audienceId },
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Remove a single contact from an audience.
+	*
+	* @example
+	* await bird.audiences.removeContact("aud_01krdgeqcxet5s7t44vh8rt9mg", "con_1");
+	*/
+	removeContact(audienceId, contactId, options) {
+		return this.call("DELETE", options, ({ signal, headers }) => unassignAudienceContact({
+			client: this.client,
+			path: {
+				audience_id: audienceId,
+				contact_id: contactId
+			},
+			headers,
+			signal
+		}));
+	}
+};
+//#endregion
+//#region src/resources/contactProperties.ts
+var ContactPropertiesResource = class extends Resource {
+	/**
+	* Define a contact property. The `key` must be unique in the workspace and is
+	* how contacts reference the field in their `data`.
+	*
+	* @example
+	* const prop = await bird.contactProperties.create({ key: "plan", type: "string" });
+	* console.log(prop.id); // "cp_…"
+	*/
+	create(params, options) {
+		return this.call("POST", options, ({ signal, headers }) => createContactProperty({
+			client: this.client,
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* List the workspace's contact properties. `await` resolves the first page;
+	* `for await` walks every property across pages.
+	*
+	* @example
+	* for await (const prop of bird.contactProperties.list()) {
+	*   console.log(prop.key, prop.type);
+	* }
+	*/
+	list(query, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listContactProperties({
+			client: this.client,
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Fetch a single contact property by id.
+	*
+	* @example
+	* const prop = await bird.contactProperties.get("cp_01krdgeqcxet5s7t44vh8rt9mg");
+	*/
+	get(propertyId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getContactProperty({
+			client: this.client,
+			path: { property_id: propertyId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Update a contact property. Only the fields you send change.
+	*
+	* @example
+	* await bird.contactProperties.update("cp_01krdgeqcxet5s7t44vh8rt9mg", { fallback_value: "free" });
+	*/
+	update(propertyId, params, options) {
+		return this.call("PATCH", options, ({ signal, headers }) => updateContactProperty({
+			client: this.client,
+			path: { property_id: propertyId },
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Archive a contact property, retiring the field without deleting its data.
+	*
+	* @example
+	* await bird.contactProperties.archive("cp_01krdgeqcxet5s7t44vh8rt9mg");
+	*/
+	archive(propertyId, options) {
+		return this.call("POST", options, ({ signal, headers }) => archiveContactProperty({
+			client: this.client,
+			path: { property_id: propertyId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Restore an archived contact property.
+	*
+	* @example
+	* await bird.contactProperties.unarchive("cp_01krdgeqcxet5s7t44vh8rt9mg");
+	*/
+	unarchive(propertyId, options) {
+		return this.call("POST", options, ({ signal, headers }) => unarchiveContactProperty({
+			client: this.client,
+			path: { property_id: propertyId },
+			headers,
+			signal
+		}));
+	}
+};
+//#endregion
+//#region src/resources/contacts.ts
+var ContactsResource = class extends Resource {
+	/**
+	* Create a contact. `email` is required and unique within the workspace; set
+	* custom fields via `data` (each key a property defined in contact properties).
+	*
+	* @example Create a contact
+	* const contact = await bird.contacts.create({
+	*   email: "jane@acme.com",
+	*   first_name: "Jane",
+	* });
+	* console.log(contact.id); // "con_…"
+	*/
+	create(params, options) {
+		return this.call("POST", options, ({ signal, headers }) => createContact({
+			client: this.client,
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* List the workspace's contacts, newest first. `await` resolves the first page;
+	* `for await` walks every contact across pages. Filter by `email`,
+	* `external_id`, or a `search` term.
+	*
+	* @example Iterate every contact, or take one page
+	* for await (const contact of bird.contacts.list({ search: "acme.com" })) {
+	*   console.log(contact.id, contact.email);
+	* }
+	* const page = await bird.contacts.list({ limit: 50 }); // page.data, page.next_cursor
+	*/
+	list(query, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listContacts({
+			client: this.client,
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Fetch a single contact by id.
+	*
+	* @example
+	* const contact = await bird.contacts.get("con_01krdgeqcxet5s7t44vh8rt9mg");
+	* contact.email;
+	*/
+	get(contactId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getContact({
+			client: this.client,
+			path: { contact_id: contactId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Update a contact. Only the fields you send change.
+	*
+	* @example
+	* const contact = await bird.contacts.update("con_01krdgeqcxet5s7t44vh8rt9mg", {
+	*   first_name: "Jane",
+	* });
+	*/
+	update(contactId, params, options) {
+		return this.call("PATCH", options, ({ signal, headers }) => updateContact({
+			client: this.client,
+			path: { contact_id: contactId },
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Delete a contact by id.
+	*
+	* @example
+	* await bird.contacts.delete("con_01krdgeqcxet5s7t44vh8rt9mg");
+	*/
+	delete(contactId, options) {
+		return this.call("DELETE", options, ({ signal, headers }) => deleteContact({
+			client: this.client,
+			path: { contact_id: contactId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Create or update many contacts in one call, matched by email. Returns a
+	* per-contact result.
+	*
+	* @example
+	* const result = await bird.contacts.batch({
+	*   contacts: [{ email: "jane@acme.com", first_name: "Jane" }],
+	* });
+	*/
+	batch(params, options) {
+		return this.call("POST", options, ({ signal, headers }) => createContactBatch({
+			client: this.client,
+			body: params,
+			headers,
+			signal
+		}));
+	}
+};
+//#endregion
+//#region src/resources/emailTemplates.ts
+var EmailTemplatesResource = class extends Resource {
+	/**
+	* Create a template and its initial editable draft. Pick the authoring format
+	* with `source` (`liquid`, `handlebars`, or `html`); the name must be unique
+	* in the workspace or the call throws a `BirdConflictError`.
+	*
+	* @example Create a template
+	* const tpl = await bird.emailTemplates.create({
+	*   name: "welcome-email",
+	*   description: "Welcome",
+	*   category: "transactional",
+	*   source: "handlebars",
+	*   subject: "Welcome, {{ first_name }}!",
+	*   html: "<h1>Hi {{ first_name }}</h1>",
+	* });
+	* console.log(tpl.id, tpl.revision); // "emt_…", 0
+	*/
+	create(params, options) {
+		return this.call("POST", options, ({ signal, headers }) => createEmailTemplate({
+			client: this.client,
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* List the workspace's templates, newest first. `await` resolves the first
+	* page; `for await` walks every template across all pages. Filter by
+	* `category`, `source`, or a case-insensitive `name` prefix.
+	*
+	* @example Iterate every template, or take one page
+	* for await (const tpl of bird.emailTemplates.list({ category: "transactional" })) {
+	*   console.log(tpl.id, tpl.name);
+	* }
+	* const page = await bird.emailTemplates.list({ limit: 50 }); // page.data, page.next_cursor
+	*/
+	list(query, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listEmailTemplates({
+			client: this.client,
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Fetch a template with its current draft content (subject, HTML, text), the
+	* draft `revision`, and its draft/published version ids.
+	*
+	* @example
+	* const tpl = await bird.emailTemplates.get("emt_abc123");
+	* tpl.subject;
+	* tpl.published_version_id; // null until first publish
+	*/
+	get(templateId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getEmailTemplate({
+			client: this.client,
+			path: { template_id: templateId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Update a template's metadata and draft content. Only the fields you send
+	* change. Pass the draft `revision` you last read; if another edit landed
+	* first the call throws a `BirdConflictError` — reload and retry.
+	*
+	* @example Edit the draft, guarded by the revision you read
+	* const tpl = await bird.emailTemplates.get("emt_abc123");
+	* const updated = await bird.emailTemplates.update("emt_abc123", {
+	*   revision: tpl.revision,
+	*   subject: "Welcome aboard, {{ first_name }}!",
+	* });
+	*/
+	update(templateId, params, options) {
+		return this.call("PATCH", options, ({ signal, headers }) => updateEmailTemplate({
+			client: this.client,
+			path: { template_id: templateId },
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Delete a template and all its versions. The name becomes available for
+	* reuse in the workspace.
+	*
+	* @example
+	* await bird.emailTemplates.delete("emt_abc123");
+	*/
+	delete(templateId, options) {
+		return this.call("DELETE", options, ({ signal, headers }) => deleteEmailTemplate({
+			client: this.client,
+			path: { template_id: templateId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Publish the current draft as a new immutable, numbered version and make it
+	* the live version used by sends. The draft stays editable. The draft must
+	* have a subject and a body, or the call throws.
+	*
+	* @example Publish, then send by template
+	* const version = await bird.emailTemplates.publish("emt_abc123");
+	* console.log(version.version_number); // 1, 2, 3…
+	* await bird.email.send({
+	*   from: "hello@acme.com",
+	*   to: ["alice@example.com"],
+	*   template: { id: "emt_abc123", parameters: { first_name: "Alice" } },
+	* });
+	*/
+	publish(templateId, options) {
+		return this.call("POST", options, ({ signal, headers }) => publishEmailTemplate({
+			client: this.client,
+			path: { template_id: templateId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* List every version of a template — the current draft plus all published
+	* versions — newest first. Returns the full set in one response (`.data`);
+	* this list is not paginated.
+	*
+	* @example
+	* const { data } = await bird.emailTemplates.listVersions("emt_abc123");
+	* for (const v of data) console.log(v.version_number, v.status);
+	*/
+	listVersions(templateId, options) {
+		return this.call("GET", options, ({ signal, headers }) => listEmailTemplateVersions({
+			client: this.client,
+			path: { template_id: templateId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Fetch a single version of a template.
+	*
+	* @example
+	* const version = await bird.emailTemplates.getVersion("emt_abc123", "emv_def456");
+	* version.status; // "draft" | "published"
+	*/
+	getVersion(templateId, versionId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getEmailTemplateVersion({
+			client: this.client,
+			path: {
+				template_id: templateId,
+				version_id: versionId
+			},
+			headers,
+			signal
+		}));
+	}
+};
+//#endregion
+//#region src/resources/sms.ts
+var SmsResource = class extends Resource {
+	/**
+	* Send one SMS to a single recipient. Supply either `text` (with a `category`)
+	* or a stored `template` (by `id` or `name`, with its `parameters`). The
+	* result is `accepted`, not yet delivered — read it back with `get` to confirm.
+	*
+	* @example Send free text
+	* const msg = await bird.sms.send({
+	*   to: "+15551234567",
+	*   text: "Your verification code is 123456.",
+	*   category: "authentication",
+	* });
+	* console.log(msg.id, msg.status);
+	*
+	* @example Send by template
+	* await bird.sms.send({
+	*   to: "+15551234567",
+	*   template: { name: "bird_otp_verification", parameters: { code: "123456" } },
+	* });
+	*/
+	send(params, options) {
+		return this.call("POST", options, ({ signal, headers }) => createSmsMessage({
+			client: this.client,
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Send up to 100 independent SMS messages in one call. Each item is a full send
+	* (free text or template); all items are validated before any are queued.
+	*
+	* @example
+	* const result = await bird.sms.sendBatch([
+	*   { to: "+15551111111", text: "Hi Alice!", category: "marketing" },
+	*   { to: "+15552222222", text: "Hi Bob!", category: "marketing" },
+	* ]);
+	*/
+	sendBatch(params, options) {
+		return this.call("POST", options, ({ signal, headers }) => createSmsMessageBatch({
+			client: this.client,
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Fetch a single SMS message: its current delivery status, segment breakdown,
+	* cost, and failure detail if it failed.
+	*
+	* @example
+	* const msg = await bird.sms.get("sms_abc123");
+	* msg.status; // "accepted" | "delivered" | …
+	*/
+	get(messageId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getSmsMessage({
+			client: this.client,
+			path: { message_id: messageId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* List SMS messages, newest first. `await` resolves the first page; `for await`
+	* walks every message across all pages. Filter by direction, status, category,
+	* recipient, sender, or tag.
+	*
+	* @example
+	* for await (const msg of bird.sms.list({ direction: "outbound" })) {
+	*   console.log(msg.id, msg.status);
+	* }
+	*/
+	list(query, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listSmsMessages({
+			client: this.client,
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+};
+//#endregion
+//#region src/resources/smsTemplates.ts
+var SmsTemplatesResource = class extends Resource {
+	/**
+	* List the SMS templates available to the workspace — Bird's built-in
+	* templates plus any the workspace authored. The catalogue is small and
+	* returned in full (`.data`); this list is not paginated. Filter by `scope`,
+	* `category`, or `language` (a BCP-47 language tag).
+	*
+	* @example List the built-in templates
+	* const { data } = await bird.smsTemplates.list({ scope: "system" });
+	* for (const tpl of data) console.log(tpl.id, tpl.name);
+	*/
+	list(query, options) {
+		return this.call("GET", options, ({ signal, headers }) => listSmsTemplates({
+			client: this.client,
+			query,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Fetch a single SMS template by its name or id, including its body and the
+	* variables it expects.
+	*
+	* @example
+	* const tpl = await bird.smsTemplates.get("bird_otp_verification");
+	* console.log(tpl.body, tpl.variables);
+	*/
+	get(templateRef, options) {
+		return this.call("GET", options, ({ signal, headers }) => getSmsTemplate({
+			client: this.client,
+			path: { template_ref: templateRef },
+			headers,
+			signal
+		}));
+	}
+};
+//#endregion
+//#region src/resources/webhooks.ts
+var WebhooksResource = class {
+	#secret;
+	constructor(config) {
+		this.#secret = config?.secret;
+	}
+	/**
+	* Verify a webhook delivery and return the typed event.
+	*
+	* **Pass the raw request body**, exactly as received — do NOT parse it first.
+	* The Standard Webhooks signature is computed over the raw bytes, so parsing
+	* and re-serializing before verifying is the classic webhook bug.
+	*
+	* The secret comes from `webhooks.secret` on the client; pass `{ secret }` to
+	* override per call. Throws {@link BirdWebhookVerificationError} on a bad
+	* signature, a stale timestamp, or missing/malformed headers. Unknown event
+	* types are returned as-is (handle them in a `default` case) so a newer server
+	* event can't break an older SDK.
+	*
+	* @example One call verifies the signature and returns the typed event
+	* // Pass the RAW request body; set the secret via new BirdClient({ webhooks: { secret } }).
+	* const event = bird.webhooks.unwrap(rawBody, headers);
+	* console.log(event.type); // discriminated union — narrow on event.type
+	*
+	* @example Verify and dispatch — pass the raw request body, never the parsed JSON
+	* // new BirdClient({ apiKey, webhooks: { secret } })
+	* try {
+	*   const event = bird.webhooks.unwrap(rawBody, req.headers);
+	*   switch (event.type) {
+	*     case "email.delivered":
+	*       markDelivered(event.email_id, event.recipient); // narrowed; fields are flat
+	*       break;
+	*     case "email.bounced":
+	*     case "email.complained":
+	*       suppress(event.recipient);
+	*       break;
+	*     default: // unknown future event types — an older SDK won't break on a new one
+	*   }
+	* } catch (err) {
+	*   if (err instanceof BirdWebhookVerificationError) {
+	*     // reject with 400 — bad signature, stale timestamp, or missing/malformed headers
+	*   } else throw err;
+	* }
+	*/
+	unwrap(payload, headers, options) {
+		const secret = options?.secret ?? this.#secret;
+		if (!secret) throw new Error("No webhook secret. Set `webhooks: { secret }` on the client, or pass `{ secret }` to unwrap.");
+		const wh = new Webhook(secret);
+		let verified;
+		try {
+			verified = wh.verify(payload, toHeaderRecord(headers));
+		} catch (err) {
+			throw new BirdWebhookVerificationError(err instanceof Error ? err.message : "Webhook signature verification failed");
+		}
+		return verified;
+	}
+};
+function toHeaderRecord(headers) {
+	return headers instanceof Headers ? Object.fromEntries(headers) : headers;
+}
+//#endregion
+//#region src/client.ts
+const DEFAULT_TIMEOUT_MS = 6e4;
+const DEFAULT_MAX_RETRIES = 2;
+function resolveBaseUrl(options) {
+	if (options.baseUrl) return options.baseUrl;
+	const region = options.region ?? regionFromApiKey(options.apiKey);
+	if (!region) throw new Error("Unable to determine region: API key is not in the expected bk_{region}_{token} format. Pass an explicit `region` or `baseUrl`.");
+	return baseUrlForRegion(region);
+}
+function resolveRawRequestUrl(baseUrl, path) {
+	if (!path.startsWith("/") || path.startsWith("//")) throw new TypeError("bird.request path must be an absolute path starting with a single `/`");
+	const base = new URL(baseUrl);
+	const url = new URL(baseUrl + path);
+	if (url.origin !== base.origin) throw new TypeError("bird.request path must stay on the configured Bird API origin");
+	return url;
+}
+/**
+* The Bird API client. Construct it with an API key; the region is taken from
+* the key's prefix (`bk_{region}_…`) — pass `baseUrl` or `region` to override.
+*
+* @example Construct and send
+* const bird = new BirdClient({ apiKey: process.env.BIRD_API_KEY! });
+* const msg = await bird.email.send({
+*   from: "hello@acme.com",
+*   to: ["customer@example.com"],
+*   subject: "Welcome aboard",
+*   html: "<h1>Hi there 👋</h1>",
+* });
+* console.log(msg.id);
+*
+* @example Channel defaults — set common send fields once; a per-send value always wins
+* const bird = new BirdClient({
+*   apiKey: process.env.BIRD_API_KEY!,
+*   email: { from: "hello@acme.com", category: "transactional" },
+* });
+* // `from` and `category` are filled from the defaults; both stay optional in `send`.
+* await bird.email.send({ to: ["customer@example.com"], subject: "Hi", html: "<p>hi</p>" });
+*
+* @example All client options
+* const bird = new BirdClient({
+*   apiKey: process.env.BIRD_API_KEY!,
+*   region: "eu1", // optional — override the region from the key prefix
+*   baseUrl: "http://localhost:8080", // optional — overrides region entirely (local/self-hosted)
+*   timeout: 60_000, // per-attempt timeout in ms (default 60_000)
+*   maxRetries: 2, // retry budget for transient failures (default 2)
+* });
+*/
+var BirdClient = class {
+	core;
+	#client;
+	#baseUrl;
+	#fetch;
+	#headers;
+	/** The email channel — `bird.email.send(...)`, `.get(...)`, `.list(...)`. */
+	email;
+	/** Email templates — `bird.emailTemplates.create(...)`, `.list(...)`, `.publish(...)`, … */
+	emailTemplates;
+	/** The SMS channel — `bird.sms.send(...)`, `.get(...)`, `.list(...)`. */
+	sms;
+	/** SMS templates — `bird.smsTemplates.list(...)`, `.get(...)`. */
+	smsTemplates;
+	/** Contacts — `bird.contacts.create(...)`, `.list(...)`, `.get(...)`, `.batch(...)`, … */
+	contacts;
+	/** Audiences — `bird.audiences.create(...)`, `.list(...)`, `.addContacts(...)`, … */
+	audiences;
+	/** Contact properties — `bird.contactProperties.create(...)`, `.list(...)`, `.archive(...)`, … */
+	contactProperties;
+	/** Webhooks — `bird.webhooks.unwrap(payload, headers)` verifies an inbound delivery. */
+	webhooks;
+	constructor(options) {
+		const opts = options;
+		this.#baseUrl = resolveBaseUrl(opts);
+		this.#fetch = opts.fetch ?? fetch;
+		this.#headers = {
+			...opts.defaultHeaders,
+			Authorization: `Bearer ${opts.apiKey}`,
+			"User-Agent": `bird-sdk-js/0.4.2`,
+			"Bird-Surface": "sdk-js",
+			"Bird-Version": "0.4.2"
+		};
+		const caller = detectCaller();
+		if (caller) this.#headers["Bird-Caller"] = caller;
+		this.#client = createClient(createConfig({
+			baseUrl: this.#baseUrl,
+			fetch: this.#fetch,
+			headers: this.#headers
+		}));
+		this.core = new BirdHTTPClient({
+			timeout: opts.timeout ?? DEFAULT_TIMEOUT_MS,
+			maxRetries: opts.maxRetries ?? DEFAULT_MAX_RETRIES
+		});
+		this.email = new EmailResource(this.core, this.#client, opts.email);
+		this.emailTemplates = new EmailTemplatesResource(this.core, this.#client);
+		this.sms = new SmsResource(this.core, this.#client);
+		this.smsTemplates = new SmsTemplatesResource(this.core, this.#client);
+		this.contacts = new ContactsResource(this.core, this.#client);
+		this.audiences = new AudiencesResource(this.core, this.#client);
+		this.contactProperties = new ContactPropertiesResource(this.core, this.#client);
+		this.webhooks = new WebhooksResource(opts.webhooks);
+	}
+	/**
+	* Escape hatch for endpoints the typed resources don't cover. Runs the full
+	* lifecycle (auth, retries, idempotency, error mapping); you supply the
+	* response type. Prefer a typed resource method where one exists.
+	*
+	* @throws {TypeError} if `req.path` does not start with exactly one `/` or
+	*   resolves to a different origin than the configured Bird API base URL.
+	*
+	* @example Reach an endpoint outside the curated surface — you supply the response type
+	* type Suppressions = { data: Array<{ recipient: string }> };
+	* const suppressions = await bird.request<Suppressions>({ method: "GET", path: "/v1/email/suppressions" });
+	* console.log(suppressions.data.length);
+	*/
+	request(req, options) {
+		const url = resolveRawRequestUrl(this.#baseUrl, req.path);
+		return apiPromise(this.core.request((ctx) => this.#raw(url, req, ctx, options?.headers), {
+			method: req.method,
+			idempotencyKey: options?.idempotencyKey,
+			signal: options?.signal,
+			timeout: options?.timeout,
+			maxRetries: options?.maxRetries
+		}));
+	}
+	async #raw(url, req, ctx, extraHeaders) {
+		url = new URL(url);
+		if (req.query) {
+			for (const [key, value] of Object.entries(req.query)) if (value !== void 0) url.searchParams.set(key, String(value));
+		}
+		const headers = {
+			...extraHeaders,
+			...this.#headers
+		};
+		if (ctx.idempotencyKey) headers["Idempotency-Key"] = ctx.idempotencyKey;
+		if (req.body !== void 0) headers["Content-Type"] = "application/json";
+		const response = await this.#fetch(url, {
+			method: req.method,
+			headers,
+			body: req.body !== void 0 ? JSON.stringify(req.body) : void 0,
+			signal: ctx.signal
+		});
+		if (response.ok) return {
+			data: response.status === 204 ? void 0 : await response.json().catch(() => void 0),
+			response
+		};
+		return {
+			error: await response.clone().json().catch(() => void 0),
+			response
+		};
+	}
+};
+//#endregion
+//#region src/event-types.gen.ts
+/**
+* Webhook event types known at this SDK version. The wire value is an open
+* string: a value added by a newer server is returned by `unwrap` unchanged,
+* so switch on these with a `default` branch.
+*/
+const WebhookEventType = {
+	DomainFailed: "domain.failed",
+	DomainVerified: "domain.verified",
+	EmailAccepted: "email.accepted",
+	EmailBounced: "email.bounced",
+	EmailCanceled: "email.canceled",
+	EmailClicked: "email.clicked",
+	EmailComplained: "email.complained",
+	EmailDeferred: "email.deferred",
+	EmailDelivered: "email.delivered",
+	EmailListUnsubscribed: "email.list_unsubscribed",
+	EmailMailboxMessageDelivered: "email_mailbox.message_delivered",
+	EmailMailboxMessageFailed: "email_mailbox.message_failed",
+	EmailMailboxMessageReceived: "email_mailbox.message_received",
+	EmailMailboxMessageReceivedBlocked: "email_mailbox.message_received_blocked",
+	EmailMailboxMessageReceivedUnauthenticated: "email_mailbox.message_received_unauthenticated",
+	EmailMailboxMessageSent: "email_mailbox.message_sent",
+	EmailMailboxSuspended: "email_mailbox.suspended",
+	EmailMailboxThreadCreated: "email_mailbox.thread_created",
+	EmailOpened: "email.opened",
+	EmailOutOfBandBounce: "email.out_of_band_bounce",
+	EmailProcessed: "email.processed",
+	EmailReceived: "email.received",
+	EmailRejected: "email.rejected",
+	EmailScheduled: "email.scheduled",
+	EmailSuppressionCreated: "email_suppression.created",
+	EmailUnsubscribed: "email.unsubscribed",
+	SmsAccepted: "sms.accepted",
+	SmsDelivered: "sms.delivered",
+	SmsExpired: "sms.expired",
+	SmsFailed: "sms.failed",
+	SmsRejected: "sms.rejected",
+	SmsSent: "sms.sent",
+	SmsUndelivered: "sms.undelivered"
+};
+//#endregion
+export { BirdAPIError, BirdAuthError, BirdBadRequestError, BirdBillingError, BirdClient, BirdConflictError, BirdConnectionError, BirdError, BirdInternalError, BirdMisdirectedError, BirdNotFoundError, BirdNotImplementedError, BirdPayloadTooLargeError, BirdPermissionError, BirdPreconditionError, BirdRateLimitError, BirdServiceUnavailableError, BirdTimeoutError, BirdValidationError, BirdWebhookVerificationError, WebhookEventType, baseUrlForRegion, regionFromApiKey };
+
+//# sourceMappingURL=index.mjs.map