@primitivedotdev/sdk 0.6.0 → 0.8.0

package/dist/api-BH8PnmHs.js

@@ -0,0 +1,1338 @@
+import { __export } from "./chunk-Cl8Af3a2.js";
+import { formatAddress } from "./received-email-Q6Cha3wc.js";
+
+//#region src/api/generated/core/bodySerializer.gen.ts
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+
+//#endregion
+//#region src/api/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 _fetch = options.fetch ?? globalThis.fetch;
+				const response = await _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);
+			}
+		}
+	};
+	const stream = createStream();
+	return { stream };
+}
+
+//#endregion
+//#region src/api/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$1 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues$1}`;
+			case "matrix": return `;${name}=${joinedValues$1}`;
+			case "simple": return joinedValues$1;
+			default: return `${name}=${joinedValues$1}`;
+		}
+	}
+	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$1 = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues$1}`;
+			case "label": return `.${joinedValues$1}`;
+			case "matrix": return `;${name}=${joinedValues$1}`;
+			default: return joinedValues$1;
+		}
+	}
+	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/api/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;
+	const isSerializedBody = hasBody && options.bodySerializer;
+	if (isSerializedBody) {
+		if ("serializedBody" in options) {
+			const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
+			return hasSerializedBody ? options.serializedBody : null;
+		}
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
+	return void 0;
+}
+
+//#endregion
+//#region src/api/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/api/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";
+	return;
+};
+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;
+};
+const setAuthParams = async ({ security,...options }) => {
+	for (const auth of 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;
+			case "header":
+			default:
+				options.headers.set(name, token);
+				break;
+		}
+	}
+};
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+const headersEntries = (headers) => {
+	const entries = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) continue;
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	fns = [];
+	clear() {
+		this.fns = [];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) this.fns[index] = null;
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this.fns[id] ? id : -1;
+		return this.fns.indexOf(id);
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+	use(fn) {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+
+//#endregion
+//#region src/api/generated/client/client.gen.ts
+const createClient = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config$1) => {
+		_config = mergeConfigs(_config, config$1);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams({
+			...opts,
+			security: opts.security
+		});
+		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;
+		const url = buildUrl(resolvedOpts);
+		return {
+			opts: resolvedOpts,
+			url
+		};
+	};
+	const request = async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		const requestInit = {
+			redirect: "follow",
+			...opts,
+			body: getValidRequestBody(opts)
+		};
+		let request$1 = new Request(url, requestInit);
+		for (const fn of interceptors.request.fns) if (fn) request$1 = await fn(request$1, opts);
+		const _fetch = opts.fetch;
+		let response;
+		try {
+			response = await _fetch(request$1);
+		} catch (error$1) {
+			let finalError$1 = error$1;
+			for (const fn of interceptors.error.fns) if (fn) finalError$1 = await fn(error$1, void 0, request$1, opts);
+			finalError$1 = finalError$1 || {};
+			if (opts.throwOnError) throw finalError$1;
+			return opts.responseStyle === "data" ? void 0 : {
+				error: finalError$1,
+				request: request$1,
+				response: void 0
+			};
+		}
+		for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request$1, opts);
+		const result = {
+			request: request$1,
+			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;
+					case "json":
+					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 {}
+		const error = jsonError ?? textError;
+		let finalError = error;
+		for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, response, request$1, opts);
+		finalError = finalError || {};
+		if (opts.throwOnError) throw finalError;
+		return opts.responseStyle === "data" ? void 0 : {
+			error: finalError,
+			...result
+		};
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			headers: opts.headers,
+			method,
+			onRequest: async (url$1, init) => {
+				let request$1 = new Request(url$1, init);
+				for (const fn of interceptors.request.fns) if (fn) request$1 = await fn(request$1, opts);
+				return request$1;
+			},
+			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/api/generated/client.gen.ts
+const client$1 = createClient(createConfig({ baseUrl: "https://www.primitive.dev/api/v1" }));
+
+//#endregion
+//#region src/api/generated/sdk.gen.ts
+var sdk_gen_exports = {};
+__export(sdk_gen_exports, {
+	addDomain: () => addDomain,
+	createEndpoint: () => createEndpoint,
+	createFilter: () => createFilter,
+	deleteDomain: () => deleteDomain,
+	deleteEmail: () => deleteEmail,
+	deleteEndpoint: () => deleteEndpoint,
+	deleteFilter: () => deleteFilter,
+	downloadAttachments: () => downloadAttachments,
+	downloadRawEmail: () => downloadRawEmail,
+	getAccount: () => getAccount,
+	getEmail: () => getEmail,
+	getStorageStats: () => getStorageStats,
+	getWebhookSecret: () => getWebhookSecret,
+	listDeliveries: () => listDeliveries,
+	listDomains: () => listDomains,
+	listEmails: () => listEmails,
+	listEndpoints: () => listEndpoints,
+	listFilters: () => listFilters,
+	replayDelivery: () => replayDelivery,
+	replayEmailWebhooks: () => replayEmailWebhooks,
+	rotateWebhookSecret: () => rotateWebhookSecret,
+	sendEmail: () => sendEmail,
+	testEndpoint: () => testEndpoint,
+	updateAccount: () => updateAccount,
+	updateDomain: () => updateDomain,
+	updateEndpoint: () => updateEndpoint,
+	updateFilter: () => updateFilter,
+	verifyDomain: () => verifyDomain
+});
+/**
+* Get account info
+*/
+const getAccount = (options) => (options?.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/account",
+	...options
+});
+/**
+* Update account settings
+*/
+const updateAccount = (options) => (options.client ?? client$1).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/account",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get storage usage
+*/
+const getStorageStats = (options) => (options?.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/account/storage",
+	...options
+});
+/**
+* Get webhook signing secret
+*
+* Returns the webhook signing secret for your account. If no secret
+* exists yet, one is generated automatically on first access.
+*
+*/
+const getWebhookSecret = (options) => (options?.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/account/webhook-secret",
+	...options
+});
+/**
+* Rotate webhook signing secret
+*
+* Generates a new webhook signing secret, replacing the current one.
+* Rate limited to once per 60 minutes.
+*
+*/
+const rotateWebhookSecret = (options) => (options?.client ?? client$1).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/account/webhook-secret/rotate",
+	...options
+});
+/**
+* List all domains
+*
+* Returns all verified and unverified domains for your organization,
+* sorted by creation date (newest first). Each domain includes a
+* `verified` boolean to distinguish between the two states.
+*
+*/
+const listDomains = (options) => (options?.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/domains",
+	...options
+});
+/**
+* Claim a new domain
+*
+* Creates an unverified domain claim. You will receive a
+* `verification_token` to add as a DNS TXT record before
+* calling the verify endpoint.
+*
+*/
+const addDomain = (options) => (options.client ?? client$1).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/domains",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a domain
+*
+* Deletes a verified or unverified domain claim.
+*/
+const deleteDomain = (options) => (options.client ?? client$1).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/domains/{id}",
+	...options
+});
+/**
+* Update domain settings
+*
+* Update a verified domain's settings. Only verified domains can be
+* updated. Per-domain spam thresholds require a Pro plan.
+*
+*/
+const updateDomain = (options) => (options.client ?? client$1).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/domains/{id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Verify domain ownership
+*
+* Checks DNS records (MX and TXT) to verify domain ownership.
+* On success, the domain is promoted from unverified to verified.
+* On failure, returns which checks passed and which failed.
+*
+*/
+const verifyDomain = (options) => (options.client ?? client$1).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/domains/{id}/verify",
+	...options
+});
+/**
+* List emails
+*
+* Returns a paginated list of received emails. Supports filtering by
+* domain, status, date range, and free-text search across subject,
+* sender, and recipient fields.
+*
+*/
+const listEmails = (options) => (options?.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/emails",
+	...options
+});
+/**
+* Delete an email
+*/
+const deleteEmail = (options) => (options.client ?? client$1).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/emails/{id}",
+	...options
+});
+/**
+* Get email details
+*/
+const getEmail = (options) => (options.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/emails/{id}",
+	...options
+});
+/**
+* Download raw email
+*
+* Downloads the raw RFC 822 email file (.eml). Authenticates via
+* a signed download token (provided in webhook payloads) or a
+* valid session.
+*
+*/
+const downloadRawEmail = (options) => (options.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "query",
+		name: "token",
+		type: "apiKey"
+	}],
+	url: "/emails/{id}/raw",
+	...options
+});
+/**
+* Download email attachments
+*
+* Downloads all attachments as a gzip-compressed tar archive.
+* Authenticates via a signed download token (provided in webhook
+* payloads) or a valid session.
+*
+*/
+const downloadAttachments = (options) => (options.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "query",
+		name: "token",
+		type: "apiKey"
+	}],
+	url: "/emails/{id}/attachments.tar.gz",
+	...options
+});
+/**
+* Replay email webhooks
+*
+* Re-delivers the webhook payload for this email to all active
+* endpoints matching the email's domain. Rate limited per-email
+* (short cooldown between successive replays of the same email)
+* and per-org (burst + sustained windows), sharing an org-wide
+* budget with delivery replays.
+*
+*/
+const replayEmailWebhooks = (options) => (options.client ?? client$1).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/emails/{id}/replay",
+	...options
+});
+/**
+* List webhook endpoints
+*
+* Returns all active (non-deleted) webhook endpoints.
+*/
+const listEndpoints = (options) => (options?.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/endpoints",
+	...options
+});
+/**
+* Create a webhook endpoint
+*
+* Creates a new webhook endpoint. If a deactivated endpoint with the
+* same URL and domain exists, it is reactivated instead.
+* Subject to plan limits on the number of active endpoints.
+*
+*/
+const createEndpoint = (options) => (options.client ?? client$1).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/endpoints",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a webhook endpoint
+*
+* Soft-deletes a webhook endpoint. The endpoint will no longer
+* receive webhook deliveries.
+*
+*/
+const deleteEndpoint = (options) => (options.client ?? client$1).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/endpoints/{id}",
+	...options
+});
+/**
+* Update a webhook endpoint
+*
+* Updates an active webhook endpoint. If the URL is changed, the old
+* endpoint is deactivated and a new one is created (or an existing
+* deactivated endpoint with the new URL is reactivated).
+*
+*/
+const updateEndpoint = (options) => (options.client ?? client$1).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/endpoints/{id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Send a test webhook
+*
+* Sends a sample `email.received` event to the endpoint. The request
+* includes SSRF protection (private IP rejection and DNS pinning).
+* Rate limited to 4 per minute and 30 per hour (non-exempt).
+* Successful deliveries and verified-domain endpoints are exempt
+* from the rate limit.
+*
+*/
+const testEndpoint = (options) => (options.client ?? client$1).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/endpoints/{id}/test",
+	...options
+});
+/**
+* List filter rules
+*
+* Returns all whitelist and blocklist filter rules.
+*/
+const listFilters = (options) => (options?.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/filters",
+	...options
+});
+/**
+* Create a filter rule
+*
+* Creates a new whitelist or blocklist filter. Per-domain filters
+* require a Pro plan. Patterns are stored as lowercase.
+*
+*/
+const createFilter = (options) => (options.client ?? client$1).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/filters",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a filter rule
+*/
+const deleteFilter = (options) => (options.client ?? client$1).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/filters/{id}",
+	...options
+});
+/**
+* Update a filter rule
+*
+* Toggle a filter's enabled state.
+*/
+const updateFilter = (options) => (options.client ?? client$1).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/filters/{id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List webhook deliveries
+*
+* Returns a paginated list of webhook delivery attempts. Each delivery
+* includes a nested `email` object with sender, recipient, and subject.
+*
+*/
+const listDeliveries = (options) => (options?.client ?? client$1).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/webhooks/deliveries",
+	...options
+});
+/**
+* Replay a webhook delivery
+*
+* Re-sends the stored webhook payload from a previous delivery attempt.
+* If the original endpoint is still active, it is targeted. If the
+* original endpoint was deleted, the oldest active endpoint is used.
+* Deactivated endpoints cannot be replayed to. Rate limited per-org,
+* sharing an org-wide budget with email replays.
+*
+*/
+const replayDelivery = (options) => (options.client ?? client$1).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/webhooks/deliveries/{id}/replay",
+	...options
+});
+/**
+* Send outbound email
+*
+* Sends an outbound email through Primitive's outbound relay. By default
+* the request returns once the relay accepts the message for delivery.
+* Set `wait: true` to wait for the first downstream SMTP delivery outcome.
+*
+*/
+const sendEmail = (options) => (options.client ?? client$1).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/send-mail",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+
+//#endregion
+//#region src/api/index.ts
+const DEFAULT_BASE_URL = "https://www.primitive.dev/api/v1";
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const MAX_THREAD_REFERENCES = 100;
+const MAX_THREAD_HEADER_BYTES = 8 * 1024;
+const MAX_FROM_HEADER_LENGTH = 998;
+const MAX_TO_HEADER_LENGTH = 320;
+function createDefaultAuth(apiKey) {
+	return (security) => {
+		if (security.type === "http" && security.scheme === "bearer") return apiKey;
+		return void 0;
+	};
+}
+function validateAddressHeader(field, value) {
+	const trimmed = value.trim();
+	const maxLength = field === "from" ? MAX_FROM_HEADER_LENGTH : MAX_TO_HEADER_LENGTH;
+	if (trimmed.length < 3) throw new TypeError(`${field} must be at least 3 characters`);
+	if (trimmed.length > maxLength) throw new TypeError(`${field} must be at most ${maxLength} characters`);
+}
+function validateEmailAddress(field, value) {
+	if (!EMAIL_REGEX.test(value) && !/^.+<[^\s@]+@[^\s@]+\.[^\s@]+>$/.test(value)) throw new TypeError(`${field} must be a valid email address`);
+}
+function validateThreadHeaderValue(field, value) {
+	if (value.trim().length === 0) throw new TypeError(`${field} must be a non-empty string`);
+	if ([...value].some((char) => {
+		const code = char.charCodeAt(0);
+		return code <= 31 || code === 127;
+	})) throw new TypeError(`${field} must not contain control characters`);
+	if (value.length > 998) throw new TypeError(`${field} must be at most 998 characters`);
+}
+function validateSendInput(input) {
+	validateAddressHeader("from", input.from);
+	validateAddressHeader("to", input.to);
+	validateEmailAddress("to", input.to);
+	if (input.subject.trim().length === 0) throw new TypeError("subject must be a non-empty string");
+	if (!input.bodyText && !input.bodyHtml) throw new TypeError("one of bodyText or bodyHtml is required");
+	if (input.thread?.inReplyTo) validateThreadHeaderValue("thread.inReplyTo", input.thread.inReplyTo);
+	if (input.thread?.references) {
+		if (input.thread.references.length > MAX_THREAD_REFERENCES) throw new TypeError(`thread.references must contain at most ${MAX_THREAD_REFERENCES} values`);
+		for (const [index, reference] of input.thread.references.entries()) validateThreadHeaderValue(`thread.references[${index}]`, reference);
+		if (input.thread.references.join(" ").length > MAX_THREAD_HEADER_BYTES) throw new TypeError(`thread.references header must be at most ${MAX_THREAD_HEADER_BYTES} characters`);
+	}
+	if (input.waitTimeoutMs !== void 0) {
+		if (!Number.isInteger(input.waitTimeoutMs)) throw new TypeError("waitTimeoutMs must be an integer");
+		if (input.waitTimeoutMs < 1e3 || input.waitTimeoutMs > 3e4) throw new TypeError("waitTimeoutMs must be between 1000 and 30000");
+	}
+}
+function validateForwardInput(input) {
+	validateEmailAddress("to", input.to);
+	if (input.subject !== void 0 && input.subject.trim().length === 0) throw new TypeError("subject must be a non-empty string");
+}
+function parseApiErrorPayload(payload) {
+	const fallback = {
+		message: "Primitive API request failed",
+		code: void 0,
+		gates: void 0,
+		requestId: void 0,
+		details: void 0
+	};
+	if (!payload || typeof payload !== "object") return fallback;
+	if ("error" in payload && payload.error && typeof payload.error === "object") {
+		const err = payload.error;
+		return {
+			message: typeof err.message === "string" ? err.message : fallback.message,
+			code: typeof err.code === "string" ? err.code : void 0,
+			gates: Array.isArray(err.gates) ? err.gates : void 0,
+			requestId: typeof err.request_id === "string" ? err.request_id : void 0,
+			details: err.details && typeof err.details === "object" ? err.details : void 0
+		};
+	}
+	if ("message" in payload && typeof payload.message === "string") return {
+		...fallback,
+		message: payload.message
+	};
+	return fallback;
+}
+var PrimitiveApiError = class extends Error {
+	status;
+	code;
+	gates;
+	requestId;
+	retryAfter;
+	details;
+	payload;
+	constructor(message, options) {
+		super(message);
+		this.name = "PrimitiveApiError";
+		this.payload = options.payload;
+		this.status = options.status;
+		this.code = options.code;
+		this.gates = options.gates;
+		this.requestId = options.requestId;
+		this.retryAfter = options.retryAfter;
+		this.details = options.details;
+	}
+};
+function parseRetryAfterHeader(response) {
+	if (!response) return void 0;
+	const raw = response.headers.get("retry-after");
+	if (!raw) return void 0;
+	const seconds = Number.parseInt(raw, 10);
+	return Number.isFinite(seconds) ? seconds : void 0;
+}
+var PrimitiveApiClient = class {
+	client;
+	constructor(options = {}) {
+		const { apiKey, auth, baseUrl = DEFAULT_BASE_URL,...config } = options;
+		this.client = createClient(createConfig({
+			...config,
+			auth: auth ?? createDefaultAuth(apiKey),
+			baseUrl
+		}));
+	}
+	getConfig() {
+		return this.client.getConfig();
+	}
+	setConfig(config) {
+		return this.client.setConfig(config);
+	}
+};
+var PrimitiveClient = class extends PrimitiveApiClient {
+	async send(input) {
+		validateSendInput(input);
+		const body = {
+			from: input.from,
+			to: input.to,
+			subject: input.subject,
+			...input.bodyText !== void 0 ? { body_text: input.bodyText } : {},
+			...input.bodyHtml !== void 0 ? { body_html: input.bodyHtml } : {},
+			...input.thread?.inReplyTo ? { in_reply_to: input.thread.inReplyTo } : {},
+			...input.thread?.references?.length ? { references: input.thread.references } : {},
+			...input.wait !== void 0 ? { wait: input.wait } : {},
+			...input.waitTimeoutMs !== void 0 ? { wait_timeout_ms: input.waitTimeoutMs } : {}
+		};
+		const result = await sendEmail({
+			body,
+			...input.idempotencyKey ? { headers: { "Idempotency-Key": input.idempotencyKey } } : {},
+			client: this.client,
+			responseStyle: "fields"
+		});
+		const response = result.response;
+		if (result.error) {
+			const parsed = parseApiErrorPayload(result.error);
+			throw new PrimitiveApiError(parsed.message, {
+				payload: result.error,
+				status: response?.status,
+				code: parsed.code,
+				gates: parsed.gates,
+				requestId: parsed.requestId,
+				retryAfter: parseRetryAfterHeader(response),
+				details: parsed.details
+			});
+		}
+		if (!result.data?.data) throw new PrimitiveApiError("Primitive API returned no send result", {
+			payload: result,
+			status: response?.status
+		});
+		return mapSendResult(result.data.data);
+	}
+	async reply(email, input) {
+		const resolved = typeof input === "string" ? { text: input } : input;
+		return this.send({
+			from: resolved.from ?? email.receivedBy,
+			to: email.replyTarget.address,
+			subject: resolved.subject ?? email.replySubject,
+			bodyText: resolved.text,
+			thread: {
+				...email.thread.messageId ? { inReplyTo: email.thread.messageId } : {},
+				references: email.thread.messageId ? [...email.thread.references, email.thread.messageId] : email.thread.references
+			}
+		});
+	}
+	async forward(email, input) {
+		validateForwardInput(input);
+		return this.send({
+			from: input.from ?? email.receivedBy,
+			to: input.to,
+			subject: input.subject ?? email.forwardSubject,
+			bodyText: buildForwardText(email, input.bodyText)
+		});
+	}
+};
+function buildForwardText(email, intro) {
+	const lines = [
+		...intro ? [intro.trim(), ""] : [],
+		"---------- Forwarded message ----------",
+		`From: ${formatAddress(email.sender)}`,
+		`To: ${email.raw.email.headers.to}`,
+		`Subject: ${email.subject ?? ""}`,
+		...email.raw.email.headers.date ? [`Date: ${email.raw.email.headers.date}`] : [],
+		...email.thread.messageId ? [`Message-ID: ${email.thread.messageId}`] : [],
+		"",
+		email.text ?? ""
+	];
+	return lines.join("\n").trimEnd();
+}
+function mapSendResult(result) {
+	return {
+		id: result.id,
+		status: result.status,
+		queueId: result.queue_id,
+		accepted: result.accepted,
+		rejected: result.rejected,
+		clientIdempotencyKey: result.client_idempotency_key,
+		requestId: result.request_id,
+		contentHash: result.content_hash,
+		...result.delivery_status !== void 0 ? { deliveryStatus: result.delivery_status } : {},
+		...result.smtp_response_code !== void 0 ? { smtpResponseCode: result.smtp_response_code } : {},
+		...result.smtp_response_text !== void 0 ? { smtpResponseText: result.smtp_response_text } : {}
+	};
+}
+function createPrimitiveApiClient(options = {}) {
+	return new PrimitiveApiClient(options);
+}
+function createPrimitiveClient(options = {}) {
+	return new PrimitiveClient(options);
+}
+function client(options = {}) {
+	return new PrimitiveClient(options);
+}
+const operations = sdk_gen_exports;
+
+//#endregion
+export { DEFAULT_BASE_URL, PrimitiveApiClient, PrimitiveApiError, PrimitiveClient, addDomain, client, createEndpoint, createFilter, createPrimitiveApiClient, createPrimitiveClient, deleteDomain, deleteEmail, deleteEndpoint, deleteFilter, downloadAttachments, downloadRawEmail, getAccount, getEmail, getStorageStats, getWebhookSecret, listDeliveries, listDomains, listEmails, listEndpoints, listFilters, operations, replayDelivery, replayEmailWebhooks, rotateWebhookSecret, sendEmail, testEndpoint, updateAccount, updateDomain, updateEndpoint, updateFilter, verifyDomain };