mailchannels-sdk 1.3.1 → 1.4.0

package/dist/mailchannels.mjs

@@ -1,2200 +1,2 @@
-import { $fetch } from "ofetch";
-import { subtle } from "node:crypto";
-import { Buffer } from "node:buffer";
-import mime from "mime";
-var version = "1.3.1";
-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);
-	}
-};
+import { Attachment, Domains, Emails, MailChannels, MailChannelsClient, Metrics, SubAccounts, Suppressions, Webhooks } from "./_chunks/mailchannels.mjs";
 export { Attachment, Domains, Emails, MailChannels, MailChannelsClient, Metrics, SubAccounts, Suppressions, Webhooks };