spinupmail 0.1.0

package/dist/index.mjs

@@ -0,0 +1,864 @@
+import { z } from "zod";
+//#region ../contracts/src/index.ts
+const apiErrorSchema = z.object({
+	error: z.string().min(1),
+	details: z.string().min(1).optional()
+});
+const sortDirectionSchema = z.enum(["asc", "desc"]);
+const emailAddressSortBySchema = z.enum([
+	"createdAt",
+	"address",
+	"lastReceivedAt"
+]);
+const recentAddressActivitySortBySchema = z.enum(["recentActivity", "createdAt"]);
+const maxReceivedEmailActionSchema = z.enum(["cleanAll", "rejectNew"]);
+const emailOrderSchema = sortDirectionSchema;
+const inboundRatePolicySchema = z.object({
+	senderDomainSoftMax: z.number().int().positive().optional(),
+	senderDomainSoftWindowSeconds: z.number().int().positive().optional(),
+	senderDomainBlockMax: z.number().int().positive().optional(),
+	senderDomainBlockWindowSeconds: z.number().int().positive().optional(),
+	senderAddressBlockMax: z.number().int().positive().optional(),
+	senderAddressBlockWindowSeconds: z.number().int().positive().optional(),
+	inboxBlockMax: z.number().int().positive().optional(),
+	inboxBlockWindowSeconds: z.number().int().positive().optional(),
+	dedupeWindowSeconds: z.number().int().positive().optional(),
+	initialBlockSeconds: z.number().int().positive().optional(),
+	maxBlockSeconds: z.number().int().positive().optional()
+}).partial();
+const domainConfigSchema = z.object({
+	items: z.array(z.string().min(1)),
+	default: z.string().nullable(),
+	forcedLocalPartPrefix: z.string().nullable(),
+	maxReceivedEmailsPerOrganization: z.number().int().positive(),
+	maxReceivedEmailsPerAddress: z.number().int().positive()
+});
+const organizationStatsItemSchema = z.object({
+	organizationId: z.string().min(1),
+	memberCount: z.number().int().nonnegative(),
+	addressCount: z.number().int().nonnegative(),
+	emailCount: z.number().int().nonnegative()
+});
+z.object({ items: z.array(organizationStatsItemSchema) });
+const emailAddressSchema = z.object({
+	id: z.string().min(1),
+	address: z.string().min(1),
+	localPart: z.string().min(1),
+	domain: z.string().min(1),
+	meta: z.unknown().optional(),
+	emailCount: z.number().int().nonnegative(),
+	allowedFromDomains: z.array(z.string().min(1)).optional(),
+	blockedSenderDomains: z.array(z.string().min(1)).optional(),
+	inboundRatePolicy: inboundRatePolicySchema.nullable().optional(),
+	maxReceivedEmailCount: z.number().int().positive().nullable(),
+	maxReceivedEmailAction: maxReceivedEmailActionSchema.nullable(),
+	createdAt: z.string().nullable(),
+	createdAtMs: z.number().nullable(),
+	expiresAt: z.string().nullable(),
+	expiresAtMs: z.number().nullable(),
+	lastReceivedAt: z.string().nullable(),
+	lastReceivedAtMs: z.number().nullable()
+});
+const createEmailAddressResponseSchema = emailAddressSchema;
+const emailAddressListResponseSchema = z.object({
+	items: z.array(emailAddressSchema),
+	page: z.number().int().positive(),
+	pageSize: z.number().int().positive(),
+	totalItems: z.number().int().nonnegative(),
+	addressLimit: z.number().int().positive(),
+	totalPages: z.number().int().positive(),
+	sortBy: emailAddressSortBySchema,
+	sortDirection: sortDirectionSchema
+});
+const listEmailAddressesParamsSchema = z.object({
+	page: z.number().int().positive().optional(),
+	pageSize: z.number().int().positive().optional(),
+	search: z.string().optional(),
+	sortBy: emailAddressSortBySchema.optional(),
+	sortDirection: sortDirectionSchema.optional()
+});
+const listRecentAddressActivityParamsSchema = z.object({
+	limit: z.number().int().positive().optional(),
+	cursor: z.string().min(1).optional(),
+	search: z.string().optional(),
+	sortBy: recentAddressActivitySortBySchema.optional(),
+	sortDirection: sortDirectionSchema.optional()
+});
+const recentAddressActivityResponseSchema = z.object({
+	items: z.array(emailAddressSchema),
+	nextCursor: z.string().nullable(),
+	totalItems: z.number().int().nonnegative()
+});
+const createEmailAddressRequestSchema = z.object({
+	localPart: z.string().min(1),
+	ttlMinutes: z.number().int().positive().optional(),
+	meta: z.unknown().optional(),
+	domain: z.string().min(1).optional(),
+	allowedFromDomains: z.array(z.string().min(1)).optional(),
+	blockedSenderDomains: z.array(z.string().min(1)).optional(),
+	inboundRatePolicy: inboundRatePolicySchema.optional(),
+	maxReceivedEmailCount: z.number().int().positive().optional(),
+	maxReceivedEmailAction: maxReceivedEmailActionSchema.optional(),
+	acceptedRiskNotice: z.literal(true)
+});
+const updateEmailAddressRequestSchema = z.object({
+	localPart: z.string().min(1).optional(),
+	ttlMinutes: z.number().int().positive().nullable().optional(),
+	meta: z.unknown().optional(),
+	domain: z.string().min(1).optional(),
+	allowedFromDomains: z.array(z.string().min(1)).optional(),
+	blockedSenderDomains: z.array(z.string().min(1)).nullable().optional(),
+	inboundRatePolicy: inboundRatePolicySchema.nullable().optional(),
+	maxReceivedEmailCount: z.number().int().positive().nullable().optional(),
+	maxReceivedEmailAction: maxReceivedEmailActionSchema.optional()
+});
+const deleteEmailAddressResponseSchema = z.object({
+	id: z.string().min(1),
+	address: z.string().min(1),
+	deleted: z.literal(true)
+});
+const emailAttachmentSchema = z.object({
+	id: z.string().min(1),
+	filename: z.string().min(1),
+	contentType: z.string().min(1),
+	size: z.number().int().nonnegative(),
+	disposition: z.string().nullable(),
+	contentId: z.string().nullable(),
+	inlinePath: z.string().min(1),
+	downloadPath: z.string().min(1)
+});
+const emailListItemSchema = z.object({
+	id: z.string().min(1),
+	addressId: z.string().min(1),
+	to: z.string().min(1),
+	from: z.string().min(1),
+	sender: z.string().nullable().optional(),
+	senderLabel: z.string().min(1),
+	subject: z.string().nullable().optional(),
+	messageId: z.string().nullable().optional(),
+	rawSize: z.number().nullable().optional(),
+	rawTruncated: z.boolean(),
+	isSample: z.boolean(),
+	hasHtml: z.boolean(),
+	hasText: z.boolean(),
+	attachmentCount: z.number().int().nonnegative(),
+	receivedAt: z.string().nullable(),
+	receivedAtMs: z.number().nullable()
+});
+const emailListResponseSchema = z.object({
+	address: z.string().min(1),
+	addressId: z.string().min(1),
+	items: z.array(emailListItemSchema)
+});
+const listEmailsParamsSchema = z.object({
+	address: z.string().min(1).optional(),
+	addressId: z.string().min(1).optional(),
+	search: z.string().max(30).optional(),
+	limit: z.number().int().positive().optional(),
+	order: emailOrderSchema.optional(),
+	after: z.union([z.string(), z.number()]).optional(),
+	before: z.union([z.string(), z.number()]).optional()
+});
+const emailDetailSchema = z.object({
+	id: z.string().min(1),
+	addressId: z.string().min(1),
+	address: z.string().min(1).optional(),
+	to: z.string().min(1),
+	from: z.string().min(1),
+	sender: z.string().nullable().optional(),
+	senderLabel: z.string().min(1),
+	subject: z.string().nullable().optional(),
+	messageId: z.string().nullable().optional(),
+	headers: z.unknown(),
+	html: z.string().nullable().optional(),
+	text: z.string().nullable().optional(),
+	raw: z.string().nullable().optional(),
+	rawSize: z.number().nullable().optional(),
+	rawTruncated: z.boolean(),
+	isSample: z.boolean(),
+	rawDownloadPath: z.string().optional(),
+	attachments: z.array(emailAttachmentSchema),
+	receivedAt: z.string().nullable(),
+	receivedAtMs: z.number().nullable()
+});
+const deleteEmailResponseSchema = z.object({
+	id: z.string().min(1),
+	deleted: z.literal(true)
+});
+const emailActivityDaySchema = z.object({
+	date: z.string().min(1),
+	count: z.number().int().nonnegative()
+});
+const emailActivityResponseSchema = z.object({
+	timezone: z.string().min(1),
+	daily: z.array(emailActivityDaySchema)
+});
+const emailSummaryDomainSchema = z.object({
+	domain: z.string().min(1),
+	count: z.number().int().nonnegative()
+});
+const busiestInboxSchema = z.object({
+	addressId: z.string().min(1),
+	address: z.string().min(1),
+	count: z.number().int().nonnegative()
+});
+const dormantInboxSchema = z.object({
+	addressId: z.string().min(1),
+	address: z.string().min(1),
+	createdAt: z.string().nullable()
+});
+const emailSummaryResponseSchema = z.object({
+	totalEmailCount: z.number().int().nonnegative(),
+	attachmentCount: z.number().int().nonnegative(),
+	attachmentSizeTotal: z.number().int().nonnegative(),
+	attachmentSizeLimit: z.number().int().nonnegative(),
+	topDomains: z.array(emailSummaryDomainSchema),
+	busiestInboxes: z.array(busiestInboxSchema),
+	dormantInboxes: z.array(dormantInboxSchema)
+});
+const organizationPickerItemSchema = z.object({
+	id: z.string().min(1),
+	name: z.string().min(1),
+	slug: z.string().min(1),
+	logo: z.string().nullable().optional()
+});
+const extensionBootstrapUserSchema = z.object({
+	id: z.string().min(1),
+	email: z.string().email().nullable(),
+	name: z.string().nullable(),
+	image: z.string().nullable(),
+	emailVerified: z.boolean()
+});
+z.object({
+	user: extensionBootstrapUserSchema,
+	organizations: z.array(organizationPickerItemSchema),
+	defaultOrganizationId: z.string().min(1).nullable()
+});
+//#endregion
+//#region src/errors.ts
+var SpinupMailError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+	}
+};
+var SpinupMailValidationError = class extends SpinupMailError {
+	source;
+	issues;
+	constructor(args) {
+		super(args.message, args.cause ? { cause: args.cause } : void 0);
+		this.source = args.source;
+		this.issues = args.issues ?? [];
+	}
+};
+var SpinupMailApiError = class extends SpinupMailError {
+	status;
+	response;
+	body;
+	constructor(args) {
+		super(args.message);
+		this.status = args.status;
+		this.response = args.response;
+		this.body = args.body;
+	}
+};
+var SpinupMailTimeoutError = class extends SpinupMailError {
+	timeoutMs;
+	constructor(message, timeoutMs, options) {
+		super(message, options);
+		this.timeoutMs = timeoutMs;
+	}
+};
+//#endregion
+//#region src/file.ts
+const parseFilenameFromDisposition = (headerValue) => {
+	if (!headerValue) return null;
+	const utf8Match = headerValue.match(/filename\*=UTF-8''([^;]+)/i);
+	if (utf8Match?.[1]) try {
+		return decodeURIComponent(utf8Match[1]);
+	} catch {
+		return utf8Match[1];
+	}
+	const fallbackMatch = headerValue.match(/filename="([^"]+)"/i);
+	if (fallbackMatch?.[1]) return fallbackMatch[1];
+	return null;
+};
+var SpinupMailFile = class {
+	filename;
+	contentType;
+	contentLength;
+	response;
+	constructor(response) {
+		this.response = response;
+		this.filename = parseFilenameFromDisposition(response.headers.get("content-disposition"));
+		this.contentType = response.headers.get("content-type");
+		const contentLength = response.headers.get("content-length");
+		const parsed = contentLength ? Number(contentLength) : NaN;
+		this.contentLength = Number.isFinite(parsed) ? parsed : null;
+	}
+	arrayBuffer() {
+		return this.response.clone().arrayBuffer();
+	}
+	text() {
+		return this.response.clone().text();
+	}
+	blob() {
+		const clone = this.response.clone();
+		if (typeof clone.blob !== "function") throw new Error("Response.blob() is not available in this runtime.");
+		return clone.blob();
+	}
+};
+//#endregion
+//#region src/client.ts
+const DEFAULT_LIST_ALL_PAGE_SIZE = 50;
+const MAX_LIST_ALL_PAGES = 200;
+const DEFAULT_WAIT_TIMEOUT_MS = 3e4;
+const DEFAULT_POLL_INTERVAL_MS = 1e3;
+const DEFAULT_SPINUPMAIL_BASE_URL = "https://api.spinupmail.com";
+const RANDOM_LOCAL_PART_PREFIX = "sum";
+const RANDOM_LOCAL_PART_SIZE = 12;
+const issuePathToString = (path) => path.length === 0 ? "<root>" : path.map(String).join(".");
+const formatSchemaIssues = (issues) => issues.map((issue) => `${issuePathToString(issue.path)}: ${issue.message}`);
+const validateWithSchema = (schema, value, source, message) => {
+	const parsed = schema.safeParse(value);
+	if (!parsed.success) throw new SpinupMailValidationError({
+		message,
+		source,
+		issues: formatSchemaIssues(parsed.error.issues),
+		cause: parsed.error
+	});
+	return parsed.data;
+};
+const normalizeString = (value, label) => {
+	const normalized = value.trim();
+	if (!normalized) throw new SpinupMailValidationError({
+		message: `${label} is required.`,
+		source: "request"
+	});
+	return normalized;
+};
+const resolveFetch = (candidate) => {
+	if (candidate) return candidate;
+	if (typeof globalThis.fetch === "function") return globalThis.fetch.bind(globalThis);
+	throw new SpinupMailValidationError({
+		message: "A fetch implementation is required in this runtime.",
+		source: "request"
+	});
+};
+const normalizeBaseUrl = (baseUrl) => normalizeString(baseUrl, "baseUrl").replace(/\/+$/, "");
+const getProcessEnv = () => {
+	if (typeof process !== "undefined" && typeof process.env === "object" && process.env !== null) return process.env;
+};
+const readEnvValue = (keys) => {
+	const env = getProcessEnv();
+	if (!env) return void 0;
+	for (const key of keys) {
+		const value = env[key]?.trim();
+		if (value) return value;
+	}
+};
+const createRandomBytes = (size) => {
+	if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") return crypto.getRandomValues(new Uint8Array(size));
+	return Uint8Array.from(Array.from({ length: size }, () => Math.floor(Math.random() * 256)));
+};
+const generateRandomLocalPart = () => {
+	const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+	const bytes = createRandomBytes(RANDOM_LOCAL_PART_SIZE);
+	let suffix = "";
+	for (const byte of bytes) suffix += alphabet[byte % 36];
+	return `${RANDOM_LOCAL_PART_PREFIX}-${suffix}`;
+};
+const resolveOrganizationId = (context, organizationId, orgScoped) => {
+	if (!orgScoped) return void 0;
+	const resolved = organizationId ?? context.organizationId;
+	if (!resolved?.trim()) throw new SpinupMailValidationError({
+		message: "organizationId is required for this SpinupMail API method when using API keys.",
+		source: "request"
+	});
+	return resolved.trim();
+};
+const normalizeTimestamp = (value) => {
+	if (value === void 0) return void 0;
+	if (value instanceof Date) return value.toISOString();
+	return typeof value === "number" ? String(value) : value;
+};
+const normalizeText = (value) => (value ?? "").replace(/\s+/g, " ").trim().toLowerCase();
+const matchesText = (value, expected) => {
+	if (!expected?.trim()) return true;
+	return normalizeText(value).includes(normalizeText(expected));
+};
+const matchesAnyText = (values, expected) => {
+	if (!expected?.trim()) return true;
+	return values.some((value) => matchesText(value, expected));
+};
+const createQueryString = (values) => {
+	const query = new URLSearchParams();
+	for (const [key, value] of Object.entries(values)) {
+		if (value === void 0) continue;
+		query.set(key, String(value));
+	}
+	const serialized = query.toString();
+	return serialized.length > 0 ? `?${serialized}` : "";
+};
+const parseErrorPayload = async (response) => {
+	try {
+		const payload = await response.clone().json();
+		const parsed = apiErrorSchema.safeParse(payload);
+		if (parsed.success) return parsed.data;
+		return payload;
+	} catch {
+		const text = await response.clone().text();
+		return text ? { error: text } : void 0;
+	}
+};
+const requestJson = async (context, options) => {
+	const headers = new Headers(context.headers);
+	headers.set("x-api-key", context.apiKey);
+	headers.set("accept", "application/json");
+	const resolvedOrganizationId = resolveOrganizationId(context, options.organizationId, options.orgScoped ?? false);
+	if (resolvedOrganizationId) headers.set("x-org-id", resolvedOrganizationId);
+	let body;
+	if (options.body !== void 0) {
+		headers.set("content-type", "application/json");
+		body = JSON.stringify(options.body);
+	}
+	const response = await context.fetch(`${context.baseUrl}${options.path}`, {
+		method: options.method ?? "GET",
+		headers,
+		body,
+		signal: options.signal
+	});
+	if (!response.ok) {
+		const errorBody = await parseErrorPayload(response);
+		throw new SpinupMailApiError({
+			message: typeof errorBody === "object" && errorBody !== null && "error" in errorBody && typeof errorBody.error === "string" ? errorBody.error : response.statusText || "SpinupMail request failed",
+			status: response.status,
+			response,
+			body: errorBody
+		});
+	}
+	let payload;
+	try {
+		payload = await response.json();
+	} catch (error) {
+		throw new SpinupMailValidationError({
+			message: "SpinupMail returned a non-JSON success response.",
+			source: "response",
+			cause: error
+		});
+	}
+	return validateWithSchema(options.responseSchema, payload, "response", "SpinupMail returned an unexpected response shape.");
+};
+const requestBinary = async (context, options) => {
+	const headers = new Headers(context.headers);
+	headers.set("x-api-key", context.apiKey);
+	const resolvedOrganizationId = resolveOrganizationId(context, options.organizationId, options.orgScoped ?? false);
+	if (resolvedOrganizationId) headers.set("x-org-id", resolvedOrganizationId);
+	const response = await context.fetch(`${context.baseUrl}${options.path}`, {
+		method: "GET",
+		headers,
+		signal: options.signal
+	});
+	if (!response.ok) {
+		const errorBody = await parseErrorPayload(response);
+		throw new SpinupMailApiError({
+			message: typeof errorBody === "object" && errorBody !== null && "error" in errorBody && typeof errorBody.error === "string" ? errorBody.error : response.statusText || "SpinupMail request failed",
+			status: response.status,
+			response,
+			body: errorBody
+		});
+	}
+	return new SpinupMailFile(response);
+};
+const ensureInboxSelector = (options) => {
+	if (!options.address && !options.addressId) throw new SpinupMailValidationError({
+		message: "Either address or addressId is required.",
+		source: "request"
+	});
+};
+const validateListEmailsOptions = (options) => {
+	ensureInboxSelector(options);
+	validateWithSchema(listEmailsParamsSchema, {
+		...options,
+		after: normalizeTimestamp(options.after),
+		before: normalizeTimestamp(options.before)
+	}, "request", "Invalid listEmails options.");
+	if (options.search && (options.after !== void 0 || options.before !== void 0 || options.order === "asc")) throw new SpinupMailValidationError({
+		message: "search does not support after, before, or order='asc' parameters.",
+		source: "request"
+	});
+};
+const matchesListItemFilters = (item, options) => {
+	if (!matchesText(item.subject, options.subjectIncludes)) return false;
+	if (!matchesText(item.to, options.toIncludes)) return false;
+	if (!matchesAnyText([
+		item.from,
+		item.sender,
+		item.senderLabel
+	], options.fromIncludes)) return false;
+	return options.match ? options.match(item) : true;
+};
+const matchesDetailFilters = (detail, options) => {
+	if (!matchesText(`${detail.html ?? ""}\n${detail.text ?? ""}`, options.bodyIncludes)) return false;
+	return options.matchDetail ? options.matchDetail(detail) : true;
+};
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) {
+		reject(signal.reason ?? /* @__PURE__ */ new Error("The operation was aborted."));
+		return;
+	}
+	const timeoutId = setTimeout(() => {
+		cleanup();
+		resolve();
+	}, ms);
+	const onAbort = () => {
+		clearTimeout(timeoutId);
+		cleanup();
+		reject(signal?.reason ?? /* @__PURE__ */ new Error("The operation was aborted."));
+	};
+	const cleanup = () => {
+		signal?.removeEventListener("abort", onAbort);
+	};
+	signal?.addEventListener("abort", onAbort, { once: true });
+});
+const runPollingLoop = async (emails, options, args) => {
+	ensureInboxSelector(options);
+	validateListEmailsOptions({
+		address: options.address,
+		addressId: options.addressId,
+		search: options.search,
+		limit: options.limit,
+		order: options.order,
+		after: options.after,
+		before: options.before,
+		organizationId: options.organizationId,
+		signal: options.signal
+	});
+	const startedAt = Date.now();
+	const deadline = args.timeoutMs > 0 ? startedAt + args.timeoutMs : Number.NEGATIVE_INFINITY;
+	const seenEmailIds = /* @__PURE__ */ new Set();
+	let attempts = 0;
+	let lastResponse;
+	let lastFreshItems;
+	while (true) {
+		attempts += 1;
+		lastResponse = await emails.list({
+			address: options.address,
+			addressId: options.addressId,
+			search: options.search,
+			limit: options.limit,
+			order: options.order,
+			after: options.after,
+			before: options.before,
+			organizationId: options.organizationId,
+			signal: options.signal
+		});
+		lastFreshItems = lastResponse.items.filter((item) => {
+			if (seenEmailIds.has(item.id)) return false;
+			seenEmailIds.add(item.id);
+			return true;
+		});
+		const matchedEmail = lastFreshItems.find((item) => matchesListItemFilters(item, options)) ?? null;
+		if (matchedEmail) return {
+			response: lastResponse,
+			items: lastResponse.items,
+			freshItems: lastFreshItems,
+			matchedEmail,
+			timedOut: false,
+			attempts,
+			elapsedMs: Date.now() - startedAt,
+			polledAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		if (args.timeoutMs <= 0 || Date.now() >= deadline) break;
+		const remainingMs = deadline - Date.now();
+		if (remainingMs <= 0) break;
+		await sleep(Math.min(options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS, remainingMs), options.signal);
+	}
+	const result = {
+		response: lastResponse,
+		items: lastResponse.items,
+		freshItems: lastFreshItems,
+		matchedEmail: null,
+		timedOut: args.timeoutMs > 0,
+		attempts,
+		elapsedMs: Date.now() - startedAt,
+		polledAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (args.throwOnTimeout) throw new SpinupMailTimeoutError(`No matching email arrived before the ${args.timeoutMs}ms timeout elapsed.`, args.timeoutMs);
+	return result;
+};
+const waitForEmailDetail = async (emails, options) => {
+	ensureInboxSelector(options);
+	validateListEmailsOptions({
+		address: options.address,
+		addressId: options.addressId,
+		search: options.search,
+		limit: options.limit,
+		order: options.order,
+		after: options.after,
+		before: options.before,
+		organizationId: options.organizationId,
+		signal: options.signal
+	});
+	const startedAt = Date.now();
+	const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+	const deadline = timeoutMs > 0 ? startedAt + timeoutMs : Number.NEGATIVE_INFINITY;
+	const seenEmailIds = /* @__PURE__ */ new Set();
+	while (true) {
+		const freshCandidates = (await emails.list({
+			address: options.address,
+			addressId: options.addressId,
+			search: options.search,
+			limit: options.limit,
+			order: options.order,
+			after: options.after,
+			before: options.before,
+			organizationId: options.organizationId,
+			signal: options.signal
+		})).items.filter((item) => {
+			if (seenEmailIds.has(item.id)) return false;
+			seenEmailIds.add(item.id);
+			return matchesListItemFilters(item, options);
+		});
+		for (const item of freshCandidates) {
+			const detail = await emails.get(item.id, {
+				organizationId: options.organizationId,
+				signal: options.signal
+			});
+			if (!matchesDetailFilters(detail, options)) continue;
+			if (options.deleteAfterRead) await emails.delete(item.id, {
+				organizationId: options.organizationId,
+				signal: options.signal
+			});
+			return detail;
+		}
+		if (timeoutMs <= 0 || Date.now() >= deadline) break;
+		const remainingMs = deadline - Date.now();
+		if (remainingMs <= 0) break;
+		await sleep(Math.min(options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS, remainingMs), options.signal);
+	}
+	throw new SpinupMailTimeoutError(`No matching email arrived before the ${timeoutMs}ms timeout elapsed.`, timeoutMs);
+};
+const createSpinupMailClient = (options) => {
+	const context = {
+		baseUrl: normalizeBaseUrl(options.baseUrl),
+		apiKey: normalizeString(options.apiKey, "apiKey"),
+		organizationId: options.organizationId?.trim() || void 0,
+		fetch: resolveFetch(options.fetch),
+		headers: options.headers
+	};
+	const addresses = {
+		list: async (options = {}) => {
+			const validated = validateWithSchema(listEmailAddressesParamsSchema, options, "request", "Invalid listEmailAddresses options.");
+			return requestJson(context, {
+				path: `/api/email-addresses${createQueryString({
+					page: validated.page,
+					pageSize: validated.pageSize,
+					search: validated.search,
+					sortBy: validated.sortBy,
+					sortDirection: validated.sortDirection
+				})}`,
+				responseSchema: emailAddressListResponseSchema,
+				organizationId: options.organizationId,
+				orgScoped: true,
+				signal: options.signal
+			});
+		},
+		listAll: async (options = {}) => {
+			const items = [];
+			let page = 1;
+			let totalPages = 1;
+			while (page <= totalPages) {
+				if (page > MAX_LIST_ALL_PAGES) throw new SpinupMailValidationError({
+					message: `Address pagination exceeded the safety limit of ${MAX_LIST_ALL_PAGES} pages.`,
+					source: "request"
+				});
+				const response = await addresses.list({
+					...options,
+					page,
+					pageSize: options.pageSize ?? DEFAULT_LIST_ALL_PAGE_SIZE
+				});
+				items.push(...response.items);
+				totalPages = response.totalPages;
+				page += 1;
+			}
+			return items;
+		},
+		listRecentActivity: async (options = {}) => {
+			const validated = validateWithSchema(listRecentAddressActivityParamsSchema, options, "request", "Invalid listRecentAddressActivity options.");
+			return requestJson(context, {
+				path: `/api/email-addresses/recent-activity${createQueryString({
+					limit: validated.limit,
+					cursor: validated.cursor,
+					search: validated.search,
+					sortBy: validated.sortBy,
+					sortDirection: validated.sortDirection
+				})}`,
+				responseSchema: recentAddressActivityResponseSchema,
+				organizationId: options.organizationId,
+				orgScoped: true,
+				signal: options.signal
+			});
+		},
+		get: (addressId, options = {}) => requestJson(context, {
+			path: `/api/email-addresses/${encodeURIComponent(normalizeString(addressId, "addressId"))}`,
+			responseSchema: emailAddressSchema,
+			organizationId: options.organizationId,
+			orgScoped: true,
+			signal: options.signal
+		}),
+		create: (payload, options = {}) => {
+			return requestJson(context, {
+				method: "POST",
+				path: "/api/email-addresses",
+				responseSchema: createEmailAddressResponseSchema,
+				body: validateWithSchema(createEmailAddressRequestSchema, {
+					...payload,
+					localPart: payload.localPart?.trim() || generateRandomLocalPart()
+				}, "request", "Invalid createEmailAddress payload."),
+				organizationId: options.organizationId,
+				orgScoped: true,
+				signal: options.signal
+			});
+		},
+		update: (addressId, payload, options = {}) => requestJson(context, {
+			method: "PATCH",
+			path: `/api/email-addresses/${encodeURIComponent(normalizeString(addressId, "addressId"))}`,
+			responseSchema: emailAddressSchema,
+			body: validateWithSchema(updateEmailAddressRequestSchema, payload, "request", "Invalid updateEmailAddress payload."),
+			organizationId: options.organizationId,
+			orgScoped: true,
+			signal: options.signal
+		}),
+		delete: (addressId, options = {}) => requestJson(context, {
+			method: "DELETE",
+			path: `/api/email-addresses/${encodeURIComponent(normalizeString(addressId, "addressId"))}`,
+			responseSchema: deleteEmailAddressResponseSchema,
+			organizationId: options.organizationId,
+			orgScoped: true,
+			signal: options.signal
+		})
+	};
+	const emails = {
+		list: async (options) => {
+			validateListEmailsOptions(options);
+			return requestJson(context, {
+				path: `/api/emails${createQueryString({
+					address: options.address,
+					addressId: options.addressId,
+					search: options.search,
+					limit: options.limit,
+					order: options.order,
+					after: normalizeTimestamp(options.after),
+					before: normalizeTimestamp(options.before)
+				})}`,
+				responseSchema: emailListResponseSchema,
+				organizationId: options.organizationId,
+				orgScoped: true,
+				signal: options.signal
+			});
+		},
+		get: (emailId, options = {}) => requestJson(context, {
+			path: `/api/emails/${encodeURIComponent(normalizeString(emailId, "emailId"))}${createQueryString({ raw: options.raw ? 1 : void 0 })}`,
+			responseSchema: emailDetailSchema,
+			organizationId: options.organizationId,
+			orgScoped: true,
+			signal: options.signal
+		}),
+		delete: (emailId, options = {}) => requestJson(context, {
+			method: "DELETE",
+			path: `/api/emails/${encodeURIComponent(normalizeString(emailId, "emailId"))}`,
+			responseSchema: deleteEmailResponseSchema,
+			organizationId: options.organizationId,
+			orgScoped: true,
+			signal: options.signal
+		}),
+		getRaw: (emailId, options = {}) => requestBinary(context, {
+			path: `/api/emails/${encodeURIComponent(normalizeString(emailId, "emailId"))}/raw`,
+			organizationId: options.organizationId,
+			orgScoped: true,
+			signal: options.signal
+		}),
+		getAttachment: (emailId, attachmentId, options = {}) => requestBinary(context, {
+			path: `/api/emails/${encodeURIComponent(normalizeString(emailId, "emailId"))}/attachments/${encodeURIComponent(normalizeString(attachmentId, "attachmentId"))}${createQueryString({ inline: options.inline ? 1 : void 0 })}`,
+			organizationId: options.organizationId,
+			orgScoped: true,
+			signal: options.signal
+		})
+	};
+	return {
+		domains: { get: () => requestJson(context, {
+			path: "/api/domains",
+			responseSchema: domainConfigSchema
+		}) },
+		addresses,
+		emails,
+		stats: {
+			getEmailActivity: (options = {}) => requestJson(context, {
+				path: `/api/organizations/stats/email-activity${createQueryString({
+					days: options.days,
+					timezone: options.timezone
+				})}`,
+				responseSchema: emailActivityResponseSchema,
+				organizationId: options.organizationId,
+				orgScoped: true,
+				signal: options.signal
+			}),
+			getEmailSummary: (options = {}) => requestJson(context, {
+				path: "/api/organizations/stats/email-summary",
+				responseSchema: emailSummaryResponseSchema,
+				organizationId: options.organizationId,
+				orgScoped: true,
+				signal: options.signal
+			})
+		},
+		inboxes: {
+			poll: (options) => runPollingLoop(emails, options, {
+				timeoutMs: options.timeoutMs ?? 0,
+				throwOnTimeout: false
+			}),
+			waitForEmail: (options) => waitForEmailDetail(emails, options)
+		}
+	};
+};
+/**
+* API-key SDK for SpinupMail.
+*
+* Typical usage:
+*
+* ```ts
+* const spinupmail = new SpinupMail();
+* const address = await spinupmail.addresses.create({ acceptedRiskNotice: true });
+* const email = await spinupmail.inboxes.waitForEmail({ addressId: address.id });
+* ```
+*/
+var SpinupMail = class {
+	domains;
+	addresses;
+	emails;
+	stats;
+	inboxes;
+	/** Creates a new SDK client using constructor options or environment defaults. */
+	constructor(options = {}) {
+		const resolvedOptions = typeof options === "string" ? { apiKey: options } : options;
+		const apiKey = resolvedOptions.apiKey ?? readEnvValue(["SPINUPMAIL_API_KEY"]);
+		const baseUrl = resolvedOptions.baseUrl ?? readEnvValue(["SPINUPMAIL_BASE_URL"]) ?? DEFAULT_SPINUPMAIL_BASE_URL;
+		const organizationId = resolvedOptions.organizationId ?? readEnvValue(["SPINUPMAIL_ORGANIZATION_ID", "SPINUPMAIL_ORG_ID"]);
+		const client = createSpinupMailClient({
+			baseUrl,
+			apiKey: normalizeString(apiKey ?? "", "apiKey"),
+			organizationId,
+			fetch: resolvedOptions.fetch,
+			headers: resolvedOptions.headers
+		});
+		this.domains = client.domains;
+		this.addresses = client.addresses;
+		this.emails = client.emails;
+		this.stats = client.stats;
+		this.inboxes = client.inboxes;
+	}
+};
+//#endregion
+export { SpinupMail, SpinupMailApiError, SpinupMailError, SpinupMailFile, SpinupMailTimeoutError, SpinupMailValidationError };
+
+//# sourceMappingURL=index.mjs.map