mailchannels-sdk 1.3.0 → 1.4.0

package/dist/_chunks/mailchannels.mjs

@@ -0,0 +1,2201 @@
+import { $fetch } from "ofetch";
+import { subtle } from "node:crypto";
+import { Buffer } from "node:buffer";
+import mime from "mime";
+var name = "mailchannels-sdk";
+var version = "1.4.0";
+var MailChannelsClient = class MailChannelsClient {
+	static DEFAULT_BASE_URL = "https://api.mailchannels.net";
+	static DEFAULT_TIMEOUT = 12e4;
+	options;
+	#headers;
+	constructor(key, options = {}) {
+		if (!key) throw new Error("Missing MailChannels API key.");
+		this.options = {
+			baseUrl: options.baseUrl || MailChannelsClient.DEFAULT_BASE_URL,
+			retry: options.retry ?? false,
+			signal: options.signal,
+			timeout: options.timeout ?? MailChannelsClient.DEFAULT_TIMEOUT
+		};
+		this.#headers = {
+			"X-API-Key": key,
+			"Accept": "application/json",
+			"Content-Type": "application/json",
+			"User-Agent": `mailchannels-node/${version}`
+		};
+	}
+	async _fetch(path, options) {
+		const { headers, signal = this.options.signal, ...fetchOptions } = options;
+		return $fetch(path, {
+			baseURL: this.options.baseUrl,
+			retry: this.options.retry,
+			signal,
+			timeout: this.options.timeout === false ? void 0 : this.options.timeout,
+			...fetchOptions,
+			headers: {
+				...this.#headers,
+				...headers
+			}
+		});
+	}
+	async post(path, options) {
+		return this._fetch(path, {
+			method: "POST",
+			...options
+		});
+	}
+	async get(path, options) {
+		return this._fetch(path, {
+			method: "GET",
+			...options
+		});
+	}
+	async delete(path, options) {
+		return this._fetch(path, {
+			method: "DELETE",
+			...options
+		});
+	}
+	async put(path, options) {
+		return this._fetch(path, {
+			method: "PUT",
+			...options
+		});
+	}
+	async patch(path, options) {
+		return this._fetch(path, {
+			method: "PATCH",
+			...options
+		});
+	}
+};
+const STATUS_ERROR_TYPE_MAP = {
+	[400]: "invalid_request_error",
+	[401]: "authentication_error",
+	[403]: "permission_error",
+	[404]: "not_found",
+	[409]: "conflict_error",
+	[413]: "payload_too_large_error",
+	[422]: "unprocessable_entity_error",
+	[429]: "rate_limit_error",
+	[500]: "internal_server_error"
+};
+const createError = (message, statusCode = null, type, response = null) => {
+	return {
+		message,
+		statusCode,
+		type,
+		response
+	};
+};
+const getStatusError = (response, errors = {}) => {
+	const statusText = errors[response.status] || "Unknown error.";
+	const payload = response._data ?? response.data;
+	let details;
+	let errorResponse = null;
+	if (typeof payload === "string") details = payload;
+	else if (typeof payload === "object" && payload !== null) {
+		if (typeof payload.message === "string") details = payload.message;
+		else if (Array.isArray(payload.errors) && payload.errors.length) details = payload.errors.join(", ");
+		errorResponse = payload;
+	}
+	return createError(details ? `${statusText} ${details}` : statusText, response.status ?? null, STATUS_ERROR_TYPE_MAP[response.status] || "api_error", errorResponse);
+};
+const getResultError = (e, fallback) => {
+	return createError(e instanceof Error ? e.message : fallback, null, "application_error");
+};
+const createValidationError = (message) => {
+	return createError(message, null, "validation_error");
+};
+const validatePagination = (pagination = {}) => {
+	const { limit, offset, max } = pagination;
+	if (typeof limit === "number" && (limit < 1 || max && limit > max)) return createValidationError("The limit value " + (max ? `must be between 1 and ${max}.` : "is invalid. Only positive values are allowed."));
+	if (typeof offset === "number" && offset < 0) return createValidationError("Offset must be greater than or equal to 0.");
+	return null;
+};
+const CUSTOM_TRACKING_NAME_PATTERN = /^[a-z0-9-]+$/;
+const validateCustomTrackingName = (name) => {
+	if (!name || name.length < 1 || name.length > 64) return createValidationError("The custom tracking domain name must be between 1 and 64 characters.");
+	if (!CUSTOM_TRACKING_NAME_PATTERN.test(name)) return createValidationError("The custom tracking domain name must match ^[a-z0-9-]+$");
+	return null;
+};
+const clean = (data) => {
+	if (Array.isArray(data)) {
+		const result = [];
+		for (let i = 0; i < data.length; i++) {
+			const cleaned = clean(data[i]);
+			if (cleaned !== void 0) result.push(cleaned);
+		}
+		return result;
+	}
+	if (data && typeof data === "object" && data.constructor === Object) {
+		const result = {};
+		const obj = data;
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const cleaned = clean(obj[key]);
+			if (cleaned !== void 0) result[key] = cleaned;
+		}
+		return result;
+	}
+	return data;
+};
+const isValidEmail = (email) => {
+	return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+};
+const parseRecipientString = (input) => {
+	const trimmed = input.trim();
+	const match = trimmed.match(/^([^<]*)<([^>]*)>$/);
+	if (match) {
+		const [, name, email] = match;
+		if (!email?.trim() || !isValidEmail(email.trim())) return void 0;
+		return {
+			email: email.trim(),
+			name: name?.trim()
+		};
+	}
+	if (!isValidEmail(trimmed)) return void 0;
+	return { email: trimmed };
+};
+const parseRecipient = (recipient) => {
+	if (typeof recipient === "string") return parseRecipientString(recipient);
+	if (!recipient?.email || !isValidEmail(recipient.email)) return void 0;
+	return {
+		email: recipient.email,
+		name: recipient.name
+	};
+};
+const parseArrayRecipients = (recipients) => {
+	if (!recipients) return void 0;
+	const filtered = (typeof recipients === "string" ? [parseRecipientString(recipients)] : Array.isArray(recipients) ? recipients.map(parseRecipient) : [recipients]).filter((recipient) => Boolean(recipient));
+	return filtered.length > 0 ? filtered : void 0;
+};
+const stripPemHeaders = (pem) => pem.replace(/-----[^-]+-----|\s|#.*$/gm, "");
+const RESERVED_HEADER_NAMES = /* @__PURE__ */ new Set([
+	"authentication-results",
+	"bcc",
+	"cc",
+	"content-transfer-encoding",
+	"content-type",
+	"dkim-signature",
+	"from",
+	"message-id",
+	"received",
+	"reply-to",
+	"subject",
+	"to"
+]);
+const MAX_ATTACHMENTS = 1e3;
+const MAX_PERSONALIZATIONS = 1e3;
+const MAX_RECIPIENTS = 1e3;
+const MAX_CAMPAIGN_ID_LENGTH = 48;
+const getRecipientCount = (recipients) => recipients?.length || 0;
+const isValidTemplateValue = (value) => {
+	if (typeof value === "string" || typeof value === "boolean" || typeof value === "number") return true;
+	if (Array.isArray(value)) return value.every(isValidTemplateValue);
+	if (value !== null && typeof value === "object") return Object.values(value).every(isValidTemplateValue);
+	return false;
+};
+const validateTemplateData = (data, label) => {
+	if (data === void 0) return null;
+	if (data === null || Array.isArray(data) || typeof data !== "object") return `${label} template data must be a key/value object.`;
+	for (const [key, value] of Object.entries(data)) if (!isValidTemplateValue(value)) return `${label} template data key '${key}' has an invalid value. Values must be strings, booleans, numbers, lists, or maps.`;
+	return null;
+};
+const validateHeaderMap = (headers, label) => {
+	if (!headers) return null;
+	for (const [headerName, headerValue] of Object.entries(headers)) {
+		if (typeof headerValue !== "string") return `${label} header '${headerName}' must have a string value.`;
+		if (RESERVED_HEADER_NAMES.has(headerName.toLowerCase())) return `${label} headers cannot include the reserved header '${headerName}'.`;
+	}
+	return null;
+};
+const validateSendDkim = (dkim, label) => {
+	if (!dkim) return null;
+	if (dkim.domain && !dkim.selector) return `${label} DKIM domain requires a selector.`;
+	if (dkim.privateKey && (!dkim.domain || !dkim.selector)) return `${label} DKIM privateKey requires both a domain and selector.`;
+	return null;
+};
+const mapDkim = (dkim) => ({
+	dkim_domain: dkim?.domain,
+	dkim_private_key: dkim?.privateKey ? stripPemHeaders(dkim.privateKey) : void 0,
+	dkim_selector: dkim?.selector
+});
+const mapAttachment = (attachment) => ({
+	content: attachment.content,
+	filename: attachment.filename,
+	type: attachment.type,
+	content_id: attachment.contentId
+});
+const mapPersonalization = (personalization, index, rootTemplateData) => {
+	const to = parseArrayRecipients(personalization.to);
+	if (!to || !to.length) return `Personalization at index ${index} must include at least one recipient in the 'to' field.`;
+	if (to.length > MAX_RECIPIENTS) return `Personalization at index ${index} cannot include more than ${MAX_RECIPIENTS} 'to' recipients.`;
+	const cc = parseArrayRecipients(personalization.cc);
+	if (cc && cc.length > MAX_RECIPIENTS) return `Personalization at index ${index} cannot include more than ${MAX_RECIPIENTS} 'cc' recipients.`;
+	const bcc = parseArrayRecipients(personalization.bcc);
+	if (bcc && bcc.length > MAX_RECIPIENTS) return `Personalization at index ${index} cannot include more than ${MAX_RECIPIENTS} 'bcc' recipients.`;
+	const headerError = validateHeaderMap(personalization.headers, `Personalization at index ${index}`);
+	if (headerError) return headerError;
+	const dkimError = validateSendDkim(personalization.dkim, `Personalization at index ${index}`);
+	if (dkimError) return dkimError;
+	const templateDataError = validateTemplateData(personalization.template?.data, `Personalization at index ${index}`);
+	if (templateDataError) return templateDataError;
+	const dynamic_template_data = rootTemplateData || personalization.template?.data ? {
+		...rootTemplateData,
+		...personalization.template?.data
+	} : void 0;
+	return {
+		bcc,
+		cc,
+		...mapDkim(personalization.dkim),
+		dynamic_template_data,
+		envelope_from: parseRecipient(personalization.envelopeFrom),
+		from: parseRecipient(personalization.from),
+		headers: personalization.headers,
+		reply_to: parseRecipient(personalization.replyTo),
+		subject: personalization.subject,
+		to
+	};
+};
+const resolveAttachments = async (attachments) => {
+	if (!attachments) return;
+	return Promise.all(attachments.map((a) => Promise.resolve(a))).catch((e) => e.message);
+};
+const buildSendPayload = async (options) => {
+	const { from, html, text } = options;
+	const contentTypes = options.content ? new Set(options.content.map((item) => item.type.toLowerCase())) : void 0;
+	const parsedFrom = parseRecipient(from);
+	if (!parsedFrom || !parsedFrom.email) return "No sender provided. Use the 'from' option to specify a sender.";
+	if (!options.subject || typeof options.subject !== "string" || !options.subject.trim()) return "No subject provided. Use the 'subject' option to specify a subject.";
+	if (!text && !html && (!options.content || !options.content.length)) return "No email content provided";
+	if (html && contentTypes?.has("text/html")) return "Cannot provide both 'html' and a 'content' entry with type 'text/html'.";
+	if (text && contentTypes?.has("text/plain")) return "Cannot provide both 'text' and a 'content' entry with type 'text/plain'.";
+	if (options.attachments && options.attachments.length > MAX_ATTACHMENTS) return `The maximum number of attachments is ${MAX_ATTACHMENTS}.`;
+	if (options.campaignId && (options.campaignId.length > MAX_CAMPAIGN_ID_LENGTH || /\s/.test(options.campaignId))) return `campaignId must be ${MAX_CAMPAIGN_ID_LENGTH} characters or fewer and must not contain spaces.`;
+	const rootHeaderError = validateHeaderMap(options.headers, "Root");
+	if (rootHeaderError) return rootHeaderError;
+	const rootDkimError = validateSendDkim(options.dkim, "Root");
+	if (rootDkimError) return rootDkimError;
+	const rootTemplateDataError = validateTemplateData(options.template?.data, "Root");
+	if (rootTemplateDataError) return rootTemplateDataError;
+	if (options.personalizations?.some((p) => p.template?.data !== void 0) && !options.template?.type) return "A root template type is required when using per-personalization template data.";
+	let personalizations;
+	if (options.personalizations) {
+		if (!options.personalizations.length) return "At least one personalization must be provided.";
+		if (options.personalizations.length > MAX_PERSONALIZATIONS) return `The maximum number of personalizations is ${MAX_PERSONALIZATIONS}.`;
+		personalizations = [];
+		for (let index = 0; index < options.personalizations.length; index++) {
+			const mappedPersonalization = mapPersonalization(options.personalizations[index], index, options.template?.data);
+			if (typeof mappedPersonalization === "string") return mappedPersonalization;
+			personalizations.push(mappedPersonalization);
+		}
+	} else {
+		const parsedTo = parseArrayRecipients(options.to);
+		if (!parsedTo || !parsedTo.length) return "No recipients provided. Use the 'to' option to specify at least one recipient";
+		if (parsedTo.length > MAX_RECIPIENTS) return `The maximum number of 'to' recipients is ${MAX_RECIPIENTS}.`;
+		const parsedCc = parseArrayRecipients(options.cc);
+		if (parsedCc && parsedCc.length > MAX_RECIPIENTS) return `The maximum number of 'cc' recipients is ${MAX_RECIPIENTS}.`;
+		const parsedBcc = parseArrayRecipients(options.bcc);
+		if (parsedBcc && parsedBcc.length > MAX_RECIPIENTS) return `The maximum number of 'bcc' recipients is ${MAX_RECIPIENTS}.`;
+		personalizations = [{
+			bcc: parsedBcc,
+			cc: parsedCc,
+			dynamic_template_data: options.template?.data,
+			to: parsedTo
+		}];
+	}
+	if (options.transactional === false) {
+		if (!personalizations.every((personalization) => {
+			const personalizationDkim = personalization.dkim_selector;
+			const rootDkim = options.dkim?.selector;
+			return Boolean(personalizationDkim || rootDkim);
+		})) return "Non-transactional messages must be DKIM signed.";
+		if (personalizations.some((personalization) => {
+			return getRecipientCount(personalization.to) + getRecipientCount(personalization.cc) + getRecipientCount(personalization.bcc) !== 1;
+		})) return "Non-transactional messages must have exactly one recipient per personalization.";
+	}
+	if (options.tracking?.click?.customDomainName !== void 0) {
+		const clickCustomTrackingNameError = validateCustomTrackingName(options.tracking.click.customDomainName);
+		if (clickCustomTrackingNameError) return `Invalid click tracking: ${clickCustomTrackingNameError.message}`;
+	}
+	if (options.tracking?.open?.customDomainName !== void 0) {
+		const openCustomTrackingNameError = validateCustomTrackingName(options.tracking.open.customDomainName);
+		if (openCustomTrackingNameError) return `Invalid open tracking: ${openCustomTrackingNameError.message}`;
+	}
+	if (options.unsubscribe?.customDomainName !== void 0) {
+		const unsubscribeCustomTrackingNameError = validateCustomTrackingName(options.unsubscribe.customDomainName);
+		if (unsubscribeCustomTrackingNameError) return `Invalid unsubscribe settings: ${unsubscribeCustomTrackingNameError.message}`;
+	}
+	const content = [];
+	const template_type = options.template?.type;
+	if (text) content.push({
+		type: "text/plain",
+		value: text,
+		template_type
+	});
+	if (html) content.push({
+		type: "text/html",
+		value: html,
+		template_type
+	});
+	if (options.content) for (const item of options.content) content.push({
+		type: item.type,
+		value: item.value,
+		template_type
+	});
+	const resolvedAttachments = await resolveAttachments(options.attachments);
+	if (typeof resolvedAttachments === "string") return resolvedAttachments;
+	return {
+		attachments: resolvedAttachments?.map((a) => mapAttachment(a)),
+		campaign_id: options.campaignId,
+		...mapDkim(options.dkim),
+		envelope_from: parseRecipient(options.envelopeFrom),
+		personalizations,
+		headers: options.headers,
+		reply_to: parseRecipient(options.replyTo),
+		from: parsedFrom,
+		subject: options.subject,
+		content,
+		tracking_settings: options.tracking && {
+			click_tracking: options.tracking.click && {
+				custom_domain_name: options.tracking.click.customDomainName,
+				enable: options.tracking.click.enable
+			},
+			open_tracking: options.tracking.open && {
+				custom_domain_name: options.tracking.open.customDomainName,
+				enable: options.tracking.open.enable
+			}
+		},
+		transactional: options.transactional,
+		unsubscribe_settings: options.unsubscribe && { custom_domain_name: options.unsubscribe.customDomainName }
+	};
+};
+var Emails = class {
+	mailchannels;
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+	}
+	async _sendEmail(options, flags) {
+		let error = null;
+		const payload = await buildSendPayload(options);
+		if (typeof payload === "string") {
+			error = createValidationError(payload);
+			return {
+				data: null,
+				error
+			};
+		}
+		const endpoint = flags.async ? "/tx/v1/send-async" : "/tx/v1/send";
+		const response = await this.mailchannels.post(endpoint, {
+			query: { "dry-run": flags.dryRun },
+			body: payload,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Bad Request.",
+					[403]: "User does not have access to this feature.",
+					[413]: "The total message size should not exceed 30MB. This includes the message itself, headers, and the combined size of any attachments."
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, flags.async ? "Failed to queue email." : "Failed to send email.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		if (flags.async) {
+			const asyncResponse = response;
+			return {
+				data: clean({
+					queuedAt: asyncResponse.queued_at,
+					requestId: asyncResponse.request_id
+				}),
+				error: null
+			};
+		}
+		const syncResponse = response;
+		return {
+			data: clean({
+				rendered: syncResponse.data,
+				requestId: syncResponse.request_id,
+				results: syncResponse.results?.map((result) => ({
+					index: result.index,
+					messageId: result.message_id,
+					reason: result.reason,
+					status: result.status
+				}))
+			}),
+			error: null
+		};
+	}
+	async send(options, dryRun = false) {
+		return this._sendEmail(options, { dryRun });
+	}
+	async queue(options) {
+		return this._sendEmail(options, { async: true });
+	}
+	async sendAsync(options) {
+		return this.queue(options);
+	}
+};
+const mapDkimKey = (key) => ({
+	algorithm: key.algorithm,
+	createdAt: key.created_at,
+	dnsRecords: key.dkim_dns_records,
+	domain: key.domain,
+	gracePeriodExpiresAt: key.gracePeriodExpiresAt,
+	length: key.key_length,
+	publicKey: key.public_key,
+	retiresAt: key.retiresAt,
+	selector: key.selector,
+	status: key.status,
+	statusModifiedAt: key.status_modified_at
+});
+var DomainsDkim = class {
+	mailchannels;
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+	}
+	async create(domain, options) {
+		let error = null;
+		if (!domain) {
+			error = createValidationError("No domain provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		if (!options.selector || options.selector.length > 63) {
+			error = createValidationError("Selector must be between 1 and 63 characters.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const payload = {
+			algorithm: options.algorithm,
+			key_length: options.length,
+			selector: options.selector
+		};
+		const response = await this.mailchannels.post(`/tx/v1/domains/${encodeURIComponent(domain)}/dkim-keys`, {
+			body: payload,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Bad Request.",
+					[409]: "Key pair already created for domain, and selector."
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to create DKIM key.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean(mapDkimKey(response)),
+			error: null
+		};
+	}
+	async list(domain, options) {
+		let error = null;
+		if (!domain) {
+			error = createValidationError("No domain provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		if (options?.selector && options.selector.length > 63) {
+			error = createValidationError("Selector must be between 1 and 63 characters.");
+			return {
+				data: null,
+				error
+			};
+		}
+		error = validatePagination({
+			...options,
+			max: 100
+		});
+		if (error) return {
+			data: null,
+			error
+		};
+		const payload = {
+			selector: options?.selector,
+			status: options?.status,
+			offset: options?.offset,
+			limit: options?.limit,
+			include_dns_record: options?.includeDnsRecord
+		};
+		const response = await this.mailchannels.get(`/tx/v1/domains/${encodeURIComponent(domain)}/dkim-keys`, {
+			query: payload,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [400]: "Bad Request." });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch DKIM keys.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean(response.keys.map(mapDkimKey)),
+			error: null
+		};
+	}
+	async updateStatus(domain, options) {
+		let error = null;
+		if (!domain) {
+			error = createValidationError("No domain provided.");
+			return {
+				success: false,
+				error
+			};
+		}
+		if (!options.selector || options.selector.length > 63) {
+			error = createValidationError("Selector must be between 1 and 63 characters.");
+			return {
+				success: false,
+				error
+			};
+		}
+		const payload = { status: options.status };
+		await this.mailchannels.patch(`/tx/v1/domains/${encodeURIComponent(domain)}/dkim-keys/${encodeURIComponent(options.selector)}`, {
+			body: payload,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Bad Request.",
+					[404]: "Specified key pair not found, or no active key for rotation. This may also occur if the DKIM domain or selector path parameter is missing."
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to update status of DKIM key.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+	async rotate(domain, selector, options) {
+		let error = null;
+		if (!domain) {
+			error = createValidationError("No domain provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		if (!selector || selector.length > 63) {
+			error = createValidationError("Selector must be between 1 and 63 characters.");
+			return {
+				data: null,
+				error
+			};
+		}
+		if (!options.newKey.selector || options.newKey.selector.length > 63) {
+			error = createValidationError("New key selector must be between 1 and 63 characters.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const payload = { new_key: { selector: options.newKey.selector } };
+		const response = await this.mailchannels.post(`/tx/v1/domains/${encodeURIComponent(domain)}/dkim-keys/${encodeURIComponent(selector)}/rotate`, {
+			body: payload,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Bad Request.",
+					[404]: "Specified key pair not found.",
+					[409]: "Key pair already created for domain, and provided new key selector."
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to rotate DKIM key.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				new: mapDkimKey(response.new_key),
+				rotated: mapDkimKey(response.rotated_key)
+			}),
+			error: null
+		};
+	}
+};
+var DomainsCustomTracking = class DomainsCustomTracking {
+	mailchannels;
+	static SCOPE_VALUES = /* @__PURE__ */ new Set([
+		"click",
+		"open",
+		"unsubscribe"
+	]);
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+	}
+	async list(options) {
+		let error = null;
+		error = validatePagination({
+			...options,
+			max: 1e3
+		});
+		if (error) return {
+			data: null,
+			error
+		};
+		const response = await this.mailchannels.get("/tx/v1/custom-tracking-domains", {
+			query: options,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [400]: "Bad Request." });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch custom tracking domains.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				customTrackingDomains: response.custom_tracking_domains.map((d) => ({
+					name: d.name,
+					hostname: d.hostname,
+					scope: d.scope,
+					status: d.status,
+					createdAt: d.created_at
+				})),
+				total: response.total
+			}),
+			error: null
+		};
+	}
+	async create(name, hostname, scope) {
+		let error = null;
+		error = validateCustomTrackingName(name);
+		if (error) return {
+			data: null,
+			error
+		};
+		if (!hostname) {
+			error = createValidationError("Hostname is required.");
+			return {
+				data: null,
+				error
+			};
+		}
+		if (!scope || !DomainsCustomTracking.SCOPE_VALUES.has(scope)) {
+			error = createValidationError("Scope must be one of 'click', 'open', or 'unsubscribe'.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const payload = {
+			name,
+			hostname,
+			scope
+		};
+		let statusCode = null;
+		const response = await this.mailchannels.post("/tx/v1/custom-tracking-domains", {
+			body: payload,
+			onResponse: async ({ response }) => {
+				statusCode = response.status;
+			},
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Invalid request body.",
+					[403]: "No permission to register this domain.",
+					[409]: "A domain with the same name already exists, or the hostname and scope combination is already registered.",
+					[422]: "DNS verification incomplete. Either the TXT ownership record has not propagated yet or the hostname CNAME does not point to the required target."
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to create custom tracking domain.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		if (statusCode === 202) {
+			const dnsSetupRequiredResponse = response;
+			return {
+				data: clean({
+					dnsSetupRequired: true,
+					token: dnsSetupRequiredResponse.token,
+					txtRecordName: dnsSetupRequiredResponse.txt_record_name,
+					txtRecordValue: dnsSetupRequiredResponse.txt_record_value,
+					instructions: dnsSetupRequiredResponse.instructions
+				}),
+				error: null
+			};
+		}
+		const createResponse = response;
+		return {
+			data: clean({
+				dnsSetupRequired: false,
+				name: createResponse.name,
+				hostname: createResponse.hostname,
+				scope: createResponse.scope,
+				status: createResponse.status,
+				createdAt: createResponse.created_at
+			}),
+			error: null
+		};
+	}
+	async update(hostname, scope, options) {
+		let error = null;
+		if (!hostname) {
+			error = createValidationError("Hostname is required.");
+			return {
+				data: null,
+				error
+			};
+		}
+		if (!scope || !DomainsCustomTracking.SCOPE_VALUES.has(scope)) {
+			error = createValidationError("Scope must be one of 'click', 'open', or 'unsubscribe'.");
+			return {
+				data: null,
+				error
+			};
+		}
+		if (options.name !== void 0) {
+			error = validateCustomTrackingName(options.name);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		if (options.name === void 0 && options.status === void 0) {
+			error = createValidationError("At least one of 'name' or 'status' must be provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const payload = {
+			name: options.name,
+			status: options.status
+		};
+		let statusCode = null;
+		const response = await this.mailchannels.patch(`/tx/v1/custom-tracking-domains/${encodeURIComponent(hostname)}/${encodeURIComponent(scope)}`, {
+			body: payload,
+			onResponse: async ({ response }) => {
+				statusCode = response.status;
+			},
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Bad Request.",
+					[403]: "No permission to update this domain.",
+					[404]: `Custom tracking domain for hostname '${hostname}' and scope '${scope}' not found.`,
+					[409]: "Name already used by another domain.",
+					[422]: "DNS verification incomplete. Either the TXT ownership record has not propagated yet or the hostname CNAME does not point to the required target."
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to update custom tracking domain.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		if (statusCode === 202) {
+			const dnsSetupRequiredResponse = response;
+			return {
+				data: clean({
+					dnsSetupRequired: true,
+					token: dnsSetupRequiredResponse.token,
+					txtRecordName: dnsSetupRequiredResponse.txt_record_name,
+					txtRecordValue: dnsSetupRequiredResponse.txt_record_value,
+					instructions: dnsSetupRequiredResponse.instructions
+				}),
+				error: null
+			};
+		}
+		const updateResponse = response;
+		return {
+			data: clean({
+				dnsSetupRequired: false,
+				name: updateResponse.name,
+				hostname: updateResponse.hostname,
+				scope: updateResponse.scope,
+				status: updateResponse.status,
+				createdAt: updateResponse.created_at
+			}),
+			error: null
+		};
+	}
+	async delete(hostname, scope) {
+		let error = null;
+		if (!hostname) {
+			error = createValidationError("Hostname is required.");
+			return {
+				success: false,
+				error
+			};
+		}
+		if (!scope || !DomainsCustomTracking.SCOPE_VALUES.has(scope)) {
+			error = createValidationError("Scope must be one of 'click', 'open', or 'unsubscribe'.");
+			return {
+				success: false,
+				error
+			};
+		}
+		await this.mailchannels.delete(`/tx/v1/custom-tracking-domains/${encodeURIComponent(hostname)}/${encodeURIComponent(scope)}`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, { [400]: "Invalid hostname or scope value" });
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to delete custom tracking domain.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+};
+var Domains = class {
+	mailchannels;
+	dkim;
+	customTracking;
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+		this.dkim = new DomainsDkim(mailchannels);
+		this.customTracking = new DomainsCustomTracking(mailchannels);
+	}
+	async check(domain, options) {
+		let error = null;
+		if (!domain) {
+			error = createValidationError("No domain provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const dkimOptions = options?.dkim ? Array.isArray(options.dkim) ? options.dkim : [options.dkim] : void 0;
+		if (dkimOptions && dkimOptions.length > 10) {
+			error = createValidationError("A maximum of 10 DKIM settings can be provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		if (dkimOptions?.find(({ privateKey, selector }) => privateKey && !selector)) {
+			error = createValidationError("DKIM settings with a privateKey must also include a selector.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const payload = {
+			dkim_settings: dkimOptions?.map((dkim) => ({
+				dkim_domain: dkim.domain,
+				dkim_private_key: dkim.privateKey ? stripPemHeaders(dkim.privateKey) : void 0,
+				dkim_selector: dkim.selector
+			})),
+			domain,
+			sender_id: options?.senderId
+		};
+		const response = await this.mailchannels.post("/tx/v1/check-domain", {
+			body: payload,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Bad Request.",
+					[403]: "User does not have access to this feature."
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to check domain.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				dkim: response.check_results.dkim.map((dkimResults) => ({
+					domain: dkimResults.dkim_domain,
+					keyStatus: dkimResults.dkim_key_status,
+					selector: dkimResults.dkim_selector,
+					reason: dkimResults.reason,
+					verdict: dkimResults.verdict
+				})),
+				domainLockdown: response.check_results.domain_lockdown,
+				senderDomain: response.check_results.sender_domain,
+				spf: response.check_results.spf,
+				references: response.references
+			}),
+			error: null
+		};
+	}
+};
+const HMAC_SHA256 = {
+	name: "HMAC",
+	hash: "SHA-256"
+};
+const ED25519 = {
+	name: "Ed25519",
+	namedCurve: "Ed25519"
+};
+const encoder = new TextEncoder();
+const HEADER_CONTENT_DIGEST = "content-digest";
+const HEADER_SIGNATURE = "signature";
+const HEADER_SIGNATURE_INPUT = "signature-input";
+const signingKeyCache = /* @__PURE__ */ new Map();
+const validateContentDigest = async (header, body) => {
+	const match = header.match(/^(.*?)=:(.*?):$/);
+	if (!match) return false;
+	const [, algorithm, hash] = match;
+	if (!algorithm || !hash) return false;
+	const normalizedAlgorithm = algorithm.replace("-", "").toLowerCase();
+	if (!["sha256"].includes(normalizedAlgorithm)) return false;
+	const signatureBuffer = await subtle.digest(HMAC_SHA256.hash, encoder.encode(body));
+	return Buffer.from(signatureBuffer).toString("base64") === hash;
+};
+const extractSignature = (signatureHeader) => {
+	const signatureMatch = signatureHeader.match(/sig_\d+=:([^:]+):/);
+	return signatureMatch && signatureMatch[1] ? signatureMatch[1] : null;
+};
+const extractInputValues = (header) => {
+	const match = header.match(/^(\w+)=\(([^)]+)\);created=(\d+);alg="([^"]+)";keyid="([^"]+)"$/);
+	if (!match) return null;
+	return {
+		name: match[1],
+		timestamp: Number.parseInt(match[3], 10),
+		algorithm: match[4],
+		keyId: match[5]
+	};
+};
+async function isValidWebhook(options) {
+	const { payload, headers, cache = true } = options;
+	const contentDigest = headers[HEADER_CONTENT_DIGEST];
+	const messageSignature = headers[HEADER_SIGNATURE];
+	const signatureInput = headers[HEADER_SIGNATURE_INPUT];
+	if (!payload || !contentDigest || !messageSignature || !signatureInput || !await validateContentDigest(contentDigest, payload)) return false;
+	const signature = extractSignature(messageSignature);
+	if (!signature) return false;
+	const values = extractInputValues(signatureInput);
+	if (!values) return false;
+	if (Math.floor(Date.now() / 1e3) - values.timestamp > 300) return false;
+	const signingString = `"content-digest": ${contentDigest}
+"@signature-params": ("content-digest");created=${values.timestamp};alg="${values.algorithm}";keyid="${values.keyId}"`;
+	let publicKey = options.publicKey;
+	if (!publicKey && values.keyId) {
+		if (cache) publicKey = signingKeyCache.get(values.keyId);
+		if (!publicKey) {
+			const publicKeyResponse = await $fetch("/tx/v1/webhook/public-key", {
+				baseURL: "https://api.mailchannels.net",
+				query: { id: values.keyId }
+			}).catch(() => null);
+			if (!publicKeyResponse) return false;
+			publicKey = publicKeyResponse.key;
+			if (cache && publicKey) signingKeyCache.set(values.keyId, publicKey);
+		}
+	}
+	if (!publicKey) return false;
+	publicKey = stripPemHeaders(publicKey);
+	const encoding = "base64";
+	const format = "spki";
+	const publicKeyBuffer = Buffer.from(publicKey, encoding);
+	const webhookSignatureBuffer = Buffer.from(signature, encoding);
+	const key = await subtle.importKey(format, publicKeyBuffer, ED25519, false, ["verify"]);
+	return subtle.verify(ED25519.name, key, webhookSignatureBuffer, encoder.encode(signingString));
+}
+const ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
+const ISO_DATE_ONLY_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+const formatDateInput = (value) => {
+	if (value instanceof Date) {
+		if (Number.isNaN(value.getTime())) return null;
+		return value.toISOString();
+	}
+	if (typeof value === "string") {
+		if (!ISO_DATE_REGEX.test(value) && !ISO_DATE_ONLY_REGEX.test(value) || Number.isNaN(Date.parse(value))) return null;
+		if (ISO_DATE_REGEX.test(value)) return new Date(value).toISOString();
+	}
+	return value;
+};
+const parseDateInputs = (options) => {
+	const dates = {};
+	const keys = Object.keys(options);
+	for (const key of keys) {
+		const formatted = formatDateInput(options?.[key]);
+		if (formatted === null) return {
+			dates: null,
+			error: createValidationError(`The '${key}' value is not a valid date.`)
+		};
+		dates[key] = formatted;
+	}
+	return {
+		dates,
+		error: null
+	};
+};
+var Webhooks = class Webhooks {
+	mailchannels;
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+	}
+	async create(endpoint) {
+		let error = null;
+		if (!endpoint) {
+			error = createValidationError("No endpoint provided.");
+			return {
+				success: false,
+				error
+			};
+		}
+		if (endpoint.length > 8e3) {
+			error = createValidationError("The endpoint exceeds the maximum length of 8000 characters.");
+			return {
+				success: false,
+				error
+			};
+		}
+		await this.mailchannels.post("/tx/v1/webhook", {
+			query: { endpoint },
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [409]: `Endpoint '${endpoint}' is already enrolled to receive notifications.` });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to create webhook.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+	async list() {
+		let error = null;
+		const response = await this.mailchannels.get("/tx/v1/webhook", { onResponseError: async ({ response }) => {
+			error = getStatusError(response);
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch webhooks.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean(response.map((webhooks) => ({ webhook: webhooks.webhook }))),
+			error: null
+		};
+	}
+	async deleteAll() {
+		let error = null;
+		await this.mailchannels.delete("/tx/v1/webhook", { onResponseError: async ({ response }) => {
+			error = getStatusError(response);
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to delete webhooks.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+	async getSigningKey(id) {
+		let error = null;
+		const response = await this.mailchannels.get("/tx/v1/webhook/public-key", {
+			query: { id },
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Bad Request.",
+					[404]: `The key '${id}' is not found.`
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to get signing key.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				id: response.id,
+				key: response.key
+			}),
+			error: null
+		};
+	}
+	async validate(requestId) {
+		let error = null;
+		if (requestId && requestId.length > 28) {
+			error = createValidationError("The request id should not exceed 28 characters.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const response = await this.mailchannels.post("/tx/v1/webhook/validate", {
+			body: { request_id: requestId },
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Bad Request.",
+					[404]: "No webhooks found for the account."
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to validate webhooks.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				allPassed: response.all_passed,
+				results: response.results
+			}),
+			error: null
+		};
+	}
+	static async verify(options) {
+		let error = null;
+		if (!await isValidWebhook(options).catch(() => false)) {
+			error = createValidationError("Invalid webhook signature.");
+			return {
+				data: null,
+				error
+			};
+		}
+		try {
+			const payload = JSON.parse(options.payload);
+			if (!Array.isArray(payload)) {
+				error = createValidationError("Invalid webhook payload.");
+				return {
+					data: null,
+					error
+				};
+			}
+			return {
+				data: clean(payload.map((event) => ({
+					email: event.email,
+					customerHandle: event.customer_handle,
+					timestamp: event.timestamp,
+					smtpId: event.smtp_id,
+					event: event.event,
+					requestId: event.request_id,
+					campaignId: "campaign_id" in event ? event.campaign_id : void 0,
+					recipients: "recipients" in event ? event.recipients : void 0,
+					userAgent: "user_agent" in event ? event.user_agent : void 0,
+					ip: "ip" in event ? event.ip : void 0,
+					url: "url" in event ? event.url : void 0,
+					status: "status" in event ? event.status : void 0,
+					reason: "reason" in event ? event.reason : void 0
+				}))),
+				error: null
+			};
+		} catch {
+			error = createValidationError("Invalid webhook payload.");
+			return {
+				data: null,
+				error
+			};
+		}
+	}
+	async verify(options) {
+		return Webhooks.verify(options);
+	}
+	async batches(options) {
+		let error = null;
+		error = validatePagination({
+			...options,
+			max: 500
+		});
+		if (error) return {
+			data: null,
+			error
+		};
+		if (options?.statuses && options.statuses.length > 6) return {
+			data: null,
+			error: createValidationError("A maximum of 6 status filters can be provided.")
+		};
+		if (options?.statuses && new Set(options.statuses).size !== options.statuses.length) return {
+			data: null,
+			error: createValidationError("Status filters must be unique.")
+		};
+		const { dates, error: dateError } = parseDateInputs({
+			createdAfter: options?.createdAfter,
+			createdBefore: options?.createdBefore
+		});
+		if (!dates || dateError) return {
+			data: null,
+			error: dateError
+		};
+		if (dates.createdAfter && dates.createdBefore) {
+			const createdAfter = Date.parse(dates.createdAfter);
+			const createdBefore = Date.parse(dates.createdBefore);
+			const maxRangeMs = 26784e5;
+			if (createdBefore <= createdAfter) return {
+				data: null,
+				error: createValidationError("createdBefore must be later than createdAfter.")
+			};
+			if (createdBefore - createdAfter > maxRangeMs) return {
+				data: null,
+				error: createValidationError("The time range between createdAfter and createdBefore must not exceed 31 days.")
+			};
+		}
+		const response = await this.mailchannels.get("/tx/v1/webhook-batch", {
+			query: {
+				created_after: dates.createdAfter,
+				created_before: dates.createdBefore,
+				statuses: options?.statuses,
+				webhook: options?.webhook,
+				limit: options?.limit,
+				offset: options?.offset
+			},
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [400]: "Bad Request." });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch webhook batches.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean(response.webhook_batches.map((batch) => ({
+				batchId: batch.batch_id,
+				createdAt: batch.created_at,
+				customerHandle: batch.customer_handle,
+				duration: batch.duration,
+				eventCount: batch.event_count,
+				status: batch.status,
+				statusCode: batch.status_code,
+				webhook: batch.webhook
+			}))),
+			error: null
+		};
+	}
+	async resendBatch(batchId) {
+		let error = null;
+		const response = await this.mailchannels.post(`/tx/v1/webhook-batch/${encodeURIComponent(batchId)}/resend`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, {
+				[400]: "Bad Request. The batch ID is invalid.",
+				[404]: `The batch '${batchId}' is not found for the customer.`
+			});
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to resend webhook batch.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				batchId: response.batch_id,
+				customerHandle: response.customer_handle,
+				webhook: response.webhook,
+				createdAt: response.created_at,
+				eventCount: response.event_count,
+				duration: response.duration_in_ms,
+				statusCode: response.status_code
+			}),
+			error: null
+		};
+	}
+};
+var SubAccountsApiKeys = class {
+	mailchannels;
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+	}
+	async create(handle) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const response = await this.mailchannels.post(`/tx/v1/sub-account/${encodeURIComponent(handle)}/api-key`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, {
+				[403]: "You can't create API keys for this sub-account.",
+				[404]: `Sub-account with handle '${handle}' not found.`,
+				[422]: "You have reached the limit of API keys you can create for this sub-account."
+			});
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to create sub-account API key.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean(response),
+			error: null
+		};
+	}
+	async list(handle, options) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		error = validatePagination({
+			...options,
+			max: 1e3
+		});
+		if (error) return {
+			data: null,
+			error
+		};
+		const response = await this.mailchannels.get(`/tx/v1/sub-account/${encodeURIComponent(handle)}/api-key`, {
+			query: options,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [404]: `Sub-account with handle '${handle}' not found.` });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch sub-account API keys.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean(response.map((key) => ({
+				id: key.id,
+				key: key.key
+			}))),
+			error: null
+		};
+	}
+	async delete(handle, id) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				success: false,
+				error
+			};
+		}
+		await this.mailchannels.delete(`/tx/v1/sub-account/${encodeURIComponent(handle)}/api-key/${encodeURIComponent(id)}`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, { [400]: "Missing or invalid API key ID." });
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to delete sub-account API key.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+};
+var SubAccountsSmtpPasswords = class {
+	mailchannels;
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+	}
+	async create(handle) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const response = await this.mailchannels.post(`/tx/v1/sub-account/${encodeURIComponent(handle)}/smtp-password`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, {
+				[403]: "You can't create SMTP passwords for this sub-account.",
+				[404]: `Sub-account with handle '${handle}' not found.`,
+				[422]: "You have reached the limit of SMTP passwords you can create for this sub-account."
+			});
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to create sub-account SMTP password.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				enabled: response.enabled,
+				id: response.id,
+				smtpPassword: response.smtp_password
+			}),
+			error: null
+		};
+	}
+	async list(handle) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const response = await this.mailchannels.get(`/tx/v1/sub-account/${encodeURIComponent(handle)}/smtp-password`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, { [404]: `Sub-account with handle '${handle}' not found.` });
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch sub-account SMTP passwords.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean(response.map((password) => ({
+				enabled: password.enabled,
+				id: password.id,
+				smtpPassword: password.smtp_password
+			}))),
+			error: null
+		};
+	}
+	async delete(handle, id) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				success: false,
+				error
+			};
+		}
+		await this.mailchannels.delete(`/tx/v1/sub-account/${encodeURIComponent(handle)}/smtp-password/${encodeURIComponent(id)}`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, { [400]: "Missing or invalid SMTP password ID." });
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to delete sub-account SMTP password.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+};
+var SubAccountsLimits = class {
+	mailchannels;
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+	}
+	async get(handle) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const response = await this.mailchannels.get(`/tx/v1/sub-account/${encodeURIComponent(handle)}/limit`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, { [404]: `Sub-account with handle '${handle}' not found.` });
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch sub-account limit.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean(response),
+			error: null
+		};
+	}
+	async set(handle, options) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				success: false,
+				error
+			};
+		}
+		if (options.sends < 0) {
+			error = createValidationError("The sends value must be at least 0.");
+			return {
+				success: false,
+				error
+			};
+		}
+		await this.mailchannels.put(`/tx/v1/sub-account/${encodeURIComponent(handle)}/limit`, {
+			body: options,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Bad Request.",
+					[404]: `Sub-account with handle '${handle}' not found.`
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to set sub-account limit.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+	async delete(handle) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				success: false,
+				error
+			};
+		}
+		await this.mailchannels.delete(`/tx/v1/sub-account/${encodeURIComponent(handle)}/limit`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, { [404]: `Sub-account with handle '${handle}' not found.` });
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to delete sub-account limit.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+};
+var SubAccounts = class SubAccounts {
+	mailchannels;
+	static COMPANY_PATTERN = /^.{3,128}$/;
+	static HANDLE_PATTERN = /^[a-z0-9]{3,128}$/;
+	apiKeys;
+	smtpPasswords;
+	limits;
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+		this.apiKeys = new SubAccountsApiKeys(mailchannels);
+		this.smtpPasswords = new SubAccountsSmtpPasswords(mailchannels);
+		this.limits = new SubAccountsLimits(mailchannels);
+	}
+	async create(companyName, handle) {
+		let error = null;
+		if (!SubAccounts.COMPANY_PATTERN.test(companyName)) {
+			error = createValidationError("Invalid company name. Company name must be between 3 and 128 characters.");
+			return {
+				data: null,
+				error
+			};
+		}
+		if (handle) {
+			if (!SubAccounts.HANDLE_PATTERN.test(handle)) {
+				error = createValidationError("Invalid handle. Sub-account handle must be between 3 and 128 characters and contain only lowercase letters and numbers.");
+				return {
+					data: null,
+					error
+				};
+			}
+		}
+		const response = await this.mailchannels.post("/tx/v1/sub-account", {
+			body: {
+				company_name: companyName,
+				handle
+			},
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[403]: "The parent account does not have permission to create sub-accounts.",
+					[409]: `Sub-account with handle '${handle}' already exists.`
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to create sub-account.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				companyName: response.company_name,
+				enabled: response.enabled,
+				handle: response.handle
+			}),
+			error: null
+		};
+	}
+	async list(options) {
+		let error = null;
+		error = validatePagination({
+			...options,
+			max: 1e3
+		});
+		if (error) return {
+			data: null,
+			error
+		};
+		const response = await this.mailchannels.get("/tx/v1/sub-account", {
+			query: options,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response);
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch sub-accounts.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean(response.map((account) => ({
+				companyName: account.company_name,
+				enabled: account.enabled,
+				handle: account.handle
+			}))),
+			error: null
+		};
+	}
+	async delete(handle) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				success: false,
+				error
+			};
+		}
+		await this.mailchannels.delete(`/tx/v1/sub-account/${encodeURIComponent(handle)}`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response);
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to delete sub-account.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+	async suspend(handle) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				success: false,
+				error
+			};
+		}
+		await this.mailchannels.post(`/tx/v1/sub-account/${encodeURIComponent(handle)}/suspend`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, { [404]: `The specified sub-account '${handle}' does not exist.` });
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to suspend sub-account.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+	async activate(handle) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				success: false,
+				error
+			};
+		}
+		await this.mailchannels.post(`/tx/v1/sub-account/${encodeURIComponent(handle)}/activate`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, {
+				[403]: "The parent account does not have permission to activate the sub-account.",
+				[404]: `The specified sub-account '${handle}' does not exist.`
+			});
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to activate sub-account.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+	async getUsage(handle) {
+		let error = null;
+		if (!handle) {
+			error = createValidationError("No handle provided.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const response = await this.mailchannels.get(`/tx/v1/sub-account/${encodeURIComponent(handle)}/usage`, { onResponseError: async ({ response }) => {
+			error = getStatusError(response, { [404]: `Sub-account with handle '${handle}' not found.` });
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch sub-account usage.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				endDate: response.period_end_date,
+				startDate: response.period_start_date,
+				total: response.total_usage,
+				monthlyLimit: response.monthly_limit
+			}),
+			error: null
+		};
+	}
+	createApiKey(...args) {
+		return this.apiKeys.create(...args);
+	}
+	listApiKeys(...args) {
+		return this.apiKeys.list(...args);
+	}
+	deleteApiKey(...args) {
+		return this.apiKeys.delete(...args);
+	}
+	createSmtpPassword(...args) {
+		return this.smtpPasswords.create(...args);
+	}
+	listSmtpPasswords(...args) {
+		return this.smtpPasswords.list(...args);
+	}
+	deleteSmtpPassword(...args) {
+		return this.smtpPasswords.delete(...args);
+	}
+	setLimit(...args) {
+		return this.limits.set(...args);
+	}
+	getLimit(...args) {
+		return this.limits.get(...args);
+	}
+	deleteLimit(...args) {
+		return this.limits.delete(...args);
+	}
+};
+const mapBucket = (bucket) => {
+	return {
+		count: bucket.count,
+		periodStart: bucket.period_start
+	};
+};
+var Metrics = class {
+	mailchannels;
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+	}
+	async engagement(options) {
+		let error = null;
+		const { dates, error: dateError } = parseDateInputs({
+			startTime: options?.startTime,
+			endTime: options?.endTime
+		});
+		if (!dates || dateError) return {
+			data: null,
+			error: dateError
+		};
+		const response = await this.mailchannels.get("/tx/v1/metrics/engagement", {
+			query: {
+				start_time: dates.startTime,
+				end_time: dates.endTime,
+				campaign_id: options?.campaignId,
+				interval: options?.interval
+			},
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [400]: "Bad Request." });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch engagement metrics.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				buckets: {
+					click: response.buckets.click.map(mapBucket),
+					clickTrackingDelivered: response.buckets.click_tracking_delivered.map(mapBucket),
+					open: response.buckets.open.map(mapBucket),
+					openTrackingDelivered: response.buckets.open_tracking_delivered.map(mapBucket),
+					uniqueClick: response.buckets.unique_click?.map(mapBucket),
+					uniqueClickTrackingDelivered: response.buckets.unique_click_tracking_delivered?.map(mapBucket),
+					uniqueOpen: response.buckets.unique_open?.map(mapBucket),
+					uniqueOpenTrackingDelivered: response.buckets.unique_open_tracking_delivered?.map(mapBucket)
+				},
+				click: response.click,
+				clickTrackingDelivered: response.click_tracking_delivered,
+				endTime: response.end_time,
+				open: response.open,
+				openTrackingDelivered: response.open_tracking_delivered,
+				startTime: response.start_time,
+				uniqueClick: response.unique_click,
+				uniqueClickTrackingDelivered: response.unique_click_tracking_delivered,
+				uniqueOpen: response.unique_open,
+				uniqueOpenTrackingDelivered: response.unique_open_tracking_delivered
+			}),
+			error: null
+		};
+	}
+	async performance(options) {
+		let error = null;
+		const { dates, error: dateError } = parseDateInputs({
+			startTime: options?.startTime,
+			endTime: options?.endTime
+		});
+		if (!dates || dateError) return {
+			data: null,
+			error: dateError
+		};
+		const response = await this.mailchannels.get("/tx/v1/metrics/performance", {
+			query: {
+				start_time: dates.startTime,
+				end_time: dates.endTime,
+				campaign_id: options?.campaignId,
+				interval: options?.interval
+			},
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [400]: "Bad Request." });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch performance metrics.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				bounced: response.bounced,
+				complained: response.complained,
+				buckets: {
+					bounced: response.buckets.bounced.map(mapBucket),
+					complained: response.buckets.complained.map(mapBucket),
+					delivered: response.buckets.delivered.map(mapBucket),
+					processed: response.buckets.processed.map(mapBucket)
+				},
+				delivered: response.delivered,
+				endTime: response.end_time,
+				processed: response.processed,
+				startTime: response.start_time
+			}),
+			error: null
+		};
+	}
+	async recipientBehaviour(options) {
+		let error = null;
+		const { dates, error: dateError } = parseDateInputs({
+			startTime: options?.startTime,
+			endTime: options?.endTime
+		});
+		if (!dates || dateError) return {
+			data: null,
+			error: dateError
+		};
+		const response = await this.mailchannels.get("/tx/v1/metrics/recipient-behaviour", {
+			query: {
+				start_time: dates.startTime,
+				end_time: dates.endTime,
+				campaign_id: options?.campaignId,
+				interval: options?.interval
+			},
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [400]: "Bad Request." });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch recipient behaviour metrics.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				buckets: {
+					unsubscribeDelivered: response.buckets.unsubscribe_delivered.map(mapBucket),
+					unsubscribed: response.buckets.unsubscribed.map(mapBucket)
+				},
+				endTime: response.end_time,
+				startTime: response.start_time,
+				unsubscribeDelivered: response.unsubscribe_delivered,
+				unsubscribed: response.unsubscribed
+			}),
+			error: null
+		};
+	}
+	async volume(options) {
+		let error = null;
+		const { dates, error: dateError } = parseDateInputs({
+			startTime: options?.startTime,
+			endTime: options?.endTime
+		});
+		if (!dates || dateError) return {
+			data: null,
+			error: dateError
+		};
+		const response = await this.mailchannels.get("/tx/v1/metrics/volume", {
+			query: {
+				start_time: dates.startTime,
+				end_time: dates.endTime,
+				campaign_id: options?.campaignId,
+				interval: options?.interval
+			},
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [400]: "Bad Request." });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch volume metrics.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				buckets: {
+					delivered: response.buckets.delivered.map(mapBucket),
+					dropped: response.buckets.dropped.map(mapBucket),
+					processed: response.buckets.processed.map(mapBucket)
+				},
+				delivered: response.delivered,
+				dropped: response.dropped,
+				endTime: response.end_time,
+				processed: response.processed,
+				startTime: response.start_time
+			}),
+			error: null
+		};
+	}
+	async usage() {
+		let error = null;
+		const response = await this.mailchannels.get("/tx/v1/usage", { onResponseError: async ({ response }) => {
+			error = getStatusError(response);
+		} }).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch usage metrics.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				endDate: response.period_end_date,
+				startDate: response.period_start_date,
+				total: response.total_usage,
+				monthlyLimit: response.monthly_limit
+			}),
+			error: null
+		};
+	}
+	async senders(type, options) {
+		let error = null;
+		const { dates, error: dateError } = parseDateInputs({
+			startTime: options?.startTime,
+			endTime: options?.endTime
+		});
+		if (!dates || dateError) return {
+			data: null,
+			error: dateError
+		};
+		error = validatePagination({
+			...options,
+			max: 1e3
+		});
+		if (error) return {
+			data: null,
+			error
+		};
+		const response = await this.mailchannels.get(`/tx/v1/metrics/senders/${encodeURIComponent(type)}`, {
+			query: {
+				start_time: dates.startTime,
+				end_time: dates.endTime,
+				limit: options?.limit,
+				offset: options?.offset,
+				sort_order: options?.sortOrder
+			},
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [400]: "Bad Request." });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch senders metrics.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean({
+				endTime: response.end_time,
+				limit: response.limit,
+				offset: response.offset,
+				senders: response.senders,
+				startTime: response.start_time,
+				total: response.total
+			}),
+			error: null
+		};
+	}
+};
+var Suppressions = class {
+	mailchannels;
+	constructor(mailchannels) {
+		this.mailchannels = mailchannels;
+	}
+	async create(entriesOrOptions, options) {
+		let error = null;
+		const entries = Array.isArray(entriesOrOptions) ? entriesOrOptions : entriesOrOptions.entries;
+		const createOptions = Array.isArray(entriesOrOptions) ? options : entriesOrOptions;
+		if (entries.length > 1e3) {
+			error = createValidationError("The number of suppression entries must not exceed 1000.");
+			return {
+				success: false,
+				error
+			};
+		}
+		const payload = {
+			add_to_sub_accounts: createOptions?.addToSubAccounts,
+			suppression_entries: entries.map((entry) => ({
+				notes: entry.notes,
+				recipient: entry.recipient,
+				suppression_types: Array.from(new Set(entry.types || ["non-transactional"]))
+			}))
+		};
+		await this.mailchannels.post("/tx/v1/suppression-list", {
+			body: payload,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, {
+					[400]: "Bad Request.",
+					[409]: "Conflict. One or more suppression entries in the request already exist and cannot be created again.",
+					[413]: "Payload too large. The request exceeds the maximum allowed total of 1000 suppression entries for the parent account and/or its sub-accounts."
+				});
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to create suppression entries.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+	async delete(recipient, source) {
+		let error = null;
+		await this.mailchannels.delete(`/tx/v1/suppression-list/recipients/${encodeURIComponent(recipient)}`, {
+			query: { source },
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [400]: "Bad Request." });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to delete suppression entry.");
+		});
+		return {
+			success: !error,
+			error
+		};
+	}
+	async list(options) {
+		let error = null;
+		if (options?.recipient && options.recipient.length > 255) {
+			error = createValidationError("The recipient must not exceed 255 characters.");
+			return {
+				data: null,
+				error
+			};
+		}
+		const { dates, error: dateError } = parseDateInputs({
+			createdBefore: options?.createdBefore,
+			createdAfter: options?.createdAfter
+		});
+		if (!dates || dateError) return {
+			data: null,
+			error: dateError
+		};
+		error = validatePagination({
+			...options,
+			max: 1e3
+		});
+		if (error) return {
+			data: null,
+			error
+		};
+		const payload = {
+			recipient: options?.recipient,
+			source: options?.source,
+			created_before: dates.createdBefore,
+			created_after: dates.createdAfter,
+			limit: options?.limit,
+			offset: options?.offset
+		};
+		const response = await this.mailchannels.get("/tx/v1/suppression-list", {
+			query: payload,
+			onResponseError: async ({ response }) => {
+				error = getStatusError(response, { [400]: "Bad Request." });
+			}
+		}).catch((e) => {
+			error ||= getResultError(e, "Failed to fetch suppression entries.");
+			return null;
+		});
+		if (!response) return {
+			data: null,
+			error
+		};
+		return {
+			data: clean(response.suppression_list.map((entry) => ({
+				createdAt: entry.created_at,
+				notes: entry.notes,
+				recipient: entry.recipient,
+				sender: entry.sender,
+				source: entry.source,
+				types: entry.suppression_types
+			}))),
+			error: null
+		};
+	}
+};
+const base64Content = (data) => {
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("base64");
+	return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("base64");
+};
+const guessContentType = (filename) => {
+	return mime.getType(filename) || void 0;
+};
+var Attachment = class Attachment {
+	static fromBytes(data, options) {
+		const { filename, type, contentId } = options;
+		return {
+			content: base64Content(data),
+			filename: decodeURIComponent(filename) || "attachment",
+			type: type || guessContentType(filename),
+			contentId
+		};
+	}
+	static async fromBlob(blob, options) {
+		if (!(blob instanceof Blob)) throw new Error("Unable to create attachment: expected a Blob");
+		const bytes = await blob.arrayBuffer();
+		return Attachment.fromBytes(bytes, {
+			type: blob.type,
+			...options
+		});
+	}
+};
+var MailChannels = class extends MailChannelsClient {
+	emails = new Emails(this);
+	domains = new Domains(this);
+	webhooks = new Webhooks(this);
+	subAccounts = new SubAccounts(this);
+	metrics = new Metrics(this);
+	suppressions = new Suppressions(this);
+	constructor(key, options) {
+		super(key, options);
+	}
+};
+export { Attachment, Domains, Emails, MailChannels, MailChannelsClient, Metrics, SubAccounts, Suppressions, Webhooks, name, version };