@primitivedotdev/sdk 0.7.0 → 0.9.0

package/dist/api-COSr-Fqm.js

@@ -0,0 +1,1311 @@
+import { t as __exportAll } from "./chunk-pbuEa-1d.js";
+import { r as formatAddress } from "./received-email-D6tKtWwW.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 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;
+				await sleep(Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4));
+			}
+		}
+	};
+	return { stream: createStream() };
+}
+//#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 = (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/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;
+	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/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";
+};
+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;
+			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) => {
+		_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(_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;
+		return {
+			opts: resolvedOpts,
+			url: buildUrl(resolvedOpts)
+		};
+	};
+	const request = async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		const requestInit = {
+			redirect: "follow",
+			...opts,
+			body: getValidRequestBody(opts)
+		};
+		let request = new Request(url, requestInit);
+		for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+		const _fetch = opts.fetch;
+		let response;
+		try {
+			response = await _fetch(request);
+		} catch (error) {
+			let finalError = error;
+			for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, void 0, request, opts);
+			finalError = finalError || {};
+			if (opts.throwOnError) throw finalError;
+			return opts.responseStyle === "data" ? void 0 : {
+				error: finalError,
+				request,
+				response: void 0
+			};
+		}
+		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 {}
+		const error = jsonError ?? textError;
+		let finalError = error;
+		for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, response, request, 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, 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/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 = /* @__PURE__ */ __exportAll({
+	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;
+	};
+}
+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 result = await sendEmail({
+			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 } : {}
+			},
+			...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) {
+	return [
+		...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 ?? ""
+	].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 { sendEmail as A, listDomains as C, replayDelivery as D, listFilters as E, updateFilter as F, verifyDomain as I, updateAccount as M, updateDomain as N, replayEmailWebhooks as O, updateEndpoint as P, listDeliveries as S, listEndpoints as T, downloadRawEmail as _, client as a, getStorageStats as b, operations as c, createFilter as d, deleteDomain as f, downloadAttachments as g, deleteFilter as h, PrimitiveClient as i, testEndpoint as j, rotateWebhookSecret as k, addDomain as l, deleteEndpoint as m, PrimitiveApiClient as n, createPrimitiveApiClient as o, deleteEmail as p, PrimitiveApiError as r, createPrimitiveClient as s, DEFAULT_BASE_URL as t, createEndpoint as u, getAccount as v, listEmails as w, getWebhookSecret as x, getEmail as y };