kassza 0.12.0 → 0.14.0

package/dist/{create-once-CqdYmQD8.js → create-once-Ca2gMk1h.js}

@@ -1,9 +1,13 @@
-import { n as SzamlazzError } from "./errors-DLrb0g64.js";
+import { r as SzamlazzError } from "./errors-DtN4g5Z9.js";
 import { i as encodeUtf8 } from "./binary-D0M9U2MD.js";
-import { S as unknownOutcomeError, b as recoverAfterFailure, x as resolveRecoveryDelay, y as isUncertainOutcome } from "./issue-C6Fcjvln.js";
-import { n as toAgentDate, t as addBudapestDays } from "./dates-CXyj7Azy.js";
+import { a as optionalEl, n as buildXmlDocument, r as el } from "./serialize-B2eFh3D-.js";
+import { t as emitWarning } from "./warnings-DwTl5J-2.js";
+import { a as unknownOutcomeError, i as resolveRecoveryDelay, n as isUncertainOutcome, r as recoverAfterFailure } from "./once-CqqZxsXG.js";
+import { m as guardOnce } from "./issue-DMA1Nbr1.js";
+import { a as todayInBudapest, n as toAgentDate, t as addBudapestDays } from "./dates-CXyj7Azy.js";
 import { i as isHuf } from "./vat-v_dcWCto.js";
-import { t as calculateInvoiceItem } from "./money-DAA7OwiO.js";
+import { n as calculateInvoiceItem } from "./money-Cw457SD6.js";
+import { a as optionalText, c as requireText$1, n as agentDate$1, o as parseInvoiceResult, t as AGENT_XSD_BASE_URL, u as validationError } from "./reference-B5TATqb5.js";
 //#region src/core/actions.ts
 const SZAMLAZZ_AGENT_URL = "https://www.szamlazz.hu/szamla/";
 const AGENT_ACTIONS = {
@@ -23,12 +27,47 @@ const AGENT_ACTIONS = {
 const MAX_INVOICE_ATTACHMENTS = 5;
 //#endregion
 //#region src/core/document-events.ts
-async function emitDocumentEvent(hook, event) {
+var DocumentHookError = class extends Error {
+	name = "DocumentHookError";
+	event;
+	constructor(event, cause) {
+		super(`Az onDocument hook hibát dobott a(z) ${event.number} bizonylatnál. A bizonylat elkészült, csak a hook (például a napló mentése) maradt el: mentsd el újra az error.event alapján, és ne állítsd ki újra a bizonylatot.`, { cause });
+		this.event = event;
+	}
+	get number() {
+		return this.event.number;
+	}
+	get document() {
+		return this.event.document;
+	}
+};
+function isDocumentHookError(error) {
+	return error instanceof DocumentHookError;
+}
+function warnDocumentHook(onWarning, event, error) {
+	emitWarning(onWarning, {
+		kind: "document",
+		message: `Az onDocument hook hibát dobott a(z) ${event.number} bizonylatnál. A bizonylat elkészült, a hiba nem érinti.`,
+		error,
+		operation: `${event.kind}.${event.action}`
+	}, "console");
+}
+async function emitDocumentEvent(hook, event, options = {}) {
 	if (!hook) return;
 	try {
 		await hook(event);
 	} catch (error) {
-		console.warn(`[szamlazz] Az onDocument hook hibát dobott a(z) ${event.number} bizonylatnál. A bizonylat elkészült, a hiba nem érinti.`, error);
+		const mode = options.mode ?? "warn";
+		if (mode === "warn") {
+			warnDocumentHook(options.onWarning, event, error);
+			return;
+		}
+		if (mode === "throw") throw new DocumentHookError(event, error);
+		try {
+			await mode(error, event);
+		} catch (handlerError) {
+			throw new DocumentHookError(event, handlerError);
+		}
 	}
 }
 //#endregion
@@ -284,6 +323,176 @@ function resolveInvoice(defaults, input, now) {
 		attachments
 	};
 }
+function normalizeRegisterInput(input) {
+	const payments = "payments" in input ? input.payments : [{
+		amount: input.amount,
+		method: input.method ?? "átutalás",
+		date: input.date,
+		description: input.description
+	}];
+	if (!Array.isArray(payments) || payments.length === 0) throw validationError("Adj meg legalább egy befizetést (payments). A korábbi befizetések törléséhez a clearPayments függvényt használd.");
+	if (payments.length > 5) throw validationError(`Egy kérésben legfeljebb 5 befizetés rögzíthető, kapott: ${payments.length}.`);
+	return {
+		invoiceNumber: input.invoiceNumber,
+		taxNumber: input.taxNumber,
+		additive: input.additive ?? true,
+		payments
+	};
+}
+function normalizeClearInput(input) {
+	const target = typeof input === "string" ? { invoiceNumber: input } : input;
+	return {
+		invoiceNumber: target.invoiceNumber,
+		taxNumber: target.taxNumber,
+		additive: false,
+		payments: []
+	};
+}
+function paymentNode(payment, index) {
+	const position = index + 1;
+	if (typeof payment.amount !== "number" || !Number.isFinite(payment.amount)) throw validationError(`A(z) ${position}. befizetés összege (amount) nem véges szám.`);
+	return el("kifizetes", [
+		el("datum", payment.date === void 0 ? todayInBudapest() : agentDate$1(payment.date, "date")),
+		el("jogcim", requireText$1(payment.method, `Add meg a(z) ${position}. befizetés módját (method).`)),
+		el("osszeg", payment.amount),
+		optionalEl("leiras", optionalText(payment.description))
+	]);
+}
+function buildPaymentXml(credentials, request) {
+	const invoiceNumber = requireText$1(request.invoiceNumber, "Add meg a számla számát (invoiceNumber), amelyhez a befizetés tartozik.");
+	return buildXmlDocument({
+		root: "xmlszamlakifiz",
+		namespace: "http://www.szamlazz.hu/xmlszamlakifiz",
+		schemaLocation: `${AGENT_XSD_BASE_URL}agentkifiz/xmlszamlakifiz.xsd`,
+		children: [el("beallitasok", [
+			...credentials,
+			el("szamlaszam", invoiceNumber),
+			optionalEl("adoszam", optionalText(request.taxNumber)),
+			el("additiv", request.additive),
+			el("valaszVerzio", 2)
+		]), ...request.payments.map(paymentNode)]
+	});
+}
+function parseRegisterPaymentResponse(response, invoiceNumber) {
+	const result = parseInvoiceResult(response);
+	return {
+		invoiceNumber: result.number ?? invoiceNumber.trim(),
+		netTotal: result.netTotal,
+		grossTotal: result.grossTotal,
+		outstanding: result.outstanding,
+		buyerAccountUrl: result.buyerAccountUrl
+	};
+}
+function sendPaymentRequest(ctx, request, options) {
+	const xml = buildPaymentXml(ctx.credentials, request);
+	return ctx.execute({
+		action: "registerPayment",
+		xml,
+		signal: options.signal,
+		safeToRetry: !request.additive
+	}, (response) => parseRegisterPaymentResponse(response, request.invoiceNumber));
+}
+async function registerPayment(ctx, input, options = {}) {
+	return sendPaymentRequest(ctx, normalizeRegisterInput(input), options);
+}
+async function clearPayments(ctx, input, options = {}) {
+	return sendPaymentRequest(ctx, normalizeClearInput(input), options);
+}
+//#endregion
+//#region src/invoices/payment-once.ts
+const KEY_PATTERN = /^[A-Za-z0-9_.:-]{1,48}$/;
+function validation(message, hint) {
+	return new SzamlazzError(message, {
+		category: "validation",
+		hint
+	});
+}
+function paymentMarker(key) {
+	const trimmed = key?.trim();
+	if (!trimmed || !KEY_PATTERN.test(trimmed)) throw validation(`A registerPaymentOnce kulcsa (key) 1–48 karakter legyen, csak betű, szám és _ . : - jellel, kapott: ${String(key)}`, "Használj rövid, stabil azonosítót, például a banki tranzakció vagy a fizetés azonosítóját.");
+	return `[kassza:${trimmed}]`;
+}
+function matchingPayment(details, marker) {
+	return details.payments.find((payment) => payment.comment?.includes(marker) === true);
+}
+function describe(description, marker) {
+	const text = description?.trim();
+	return text ? `${marker} ${text}` : marker;
+}
+function unreadableMarker(invoiceNumber, marker) {
+	return new SzamlazzError(`A(z) ${invoiceNumber} számlán a befizetés rögzült, de a jelölő (${marker}) a számla lekérdezésében nem látszik, így a registerPaymentOnce nem tudja megakadályozni az ismételt rögzítést.`, {
+		category: "unexpected_response",
+		details: {
+			invoiceNumber,
+			marker,
+			registered: "true"
+		},
+		hint: "NE hívd újra ezt a rögzítést: a befizetés már rögzült. Jelezd a kassza hibajegyében; addig a befizetéseket a saját rendszeredben tartsd nyilván, és a registerPayment-et csak egyszer hívd."
+	});
+}
+const QUERY = { includePdf: false };
+async function registerPaymentOnce(api, input, options = {}, guard) {
+	const invoiceNumber = input.invoiceNumber?.trim();
+	if (!invoiceNumber) throw validation("Add meg a számla számát (invoiceNumber).");
+	if (typeof input.amount !== "number" || !Number.isFinite(input.amount) || input.amount === 0) throw validation("A befizetés összege (amount) nullától különböző véges szám legyen.");
+	const marker = paymentMarker(input.key);
+	const key = input.key.trim();
+	const delayMs = resolveRecoveryDelay(options.recoveryDelayMs);
+	const lookup = async () => {
+		return matchingPayment(await api.get(invoiceNumber, QUERY, options), marker) ?? null;
+	};
+	const base = {
+		invoiceNumber,
+		key,
+		marker
+	};
+	const run = async () => {
+		const existing = await lookup();
+		if (existing) return {
+			...base,
+			created: false,
+			existing
+		};
+		let payment;
+		try {
+			payment = await api.registerPayment({
+				invoiceNumber,
+				taxNumber: input.taxNumber,
+				additive: true,
+				amount: input.amount,
+				method: input.method ?? "átutalás",
+				date: input.date,
+				description: describe(input.description, marker)
+			}, options);
+		} catch (error) {
+			if (!isUncertainOutcome(error)) throw error;
+			const state = {};
+			const recovered = await recoverAfterFailure(lookup, delayMs, options.signal, state);
+			if (recovered) return {
+				...base,
+				created: true,
+				existing: recovered
+			};
+			throw unknownOutcomeError(error, `${invoiceNumber} számla`, {
+				subject: `${key} kulcsú befizetése`,
+				lookupError: state.lookupError,
+				method: "registerPaymentOnce"
+			});
+		}
+		const confirmed = await lookup();
+		if (!confirmed) throw unreadableMarker(invoiceNumber, marker);
+		return {
+			...base,
+			created: true,
+			payment,
+			existing: confirmed
+		};
+	};
+	return guardOnce(guard, `payment:${JSON.stringify([invoiceNumber, key])}`, options, run, (result) => ({
+		...result,
+		created: false
+	}));
+}
 //#endregion
 //#region src/receipts/create-once.ts
 function requireOrderNumber(input) {
@@ -291,7 +500,7 @@ function requireOrderNumber(input) {
 	if (!orderNumber) throw new SzamlazzError("A createOnce-hoz add meg a rendelésszámot (orderNumber), ez azonosítja a nyugtát.", { category: "validation" });
 	return orderNumber;
 }
-async function createReceiptOnce(api, input, options = {}) {
+async function createReceiptOnce(api, input, options = {}, guard) {
 	const orderNumber = requireOrderNumber(input);
 	const callId = input.callId?.trim() || orderNumber;
 	const delayMs = resolveRecoveryDelay(options.recoveryDelayMs);
@@ -299,32 +508,39 @@ async function createReceiptOnce(api, input, options = {}) {
 		orderNumber,
 		downloadPdf: input.downloadPdf
 	}, options);
-	if (options.lookupFirst !== false) {
-		const existing = await lookup();
-		if (existing) return {
-			receipt: existing,
-			created: false
-		};
-	}
-	try {
-		return {
-			receipt: await api.create({
-				...input,
-				orderNumber,
-				callId
-			}, options),
-			created: true
-		};
-	} catch (error) {
-		if (!isUncertainOutcome(error)) throw error;
-		const recovered = await recoverAfterFailure(lookup, delayMs, options.signal);
-		if (recovered) return {
-			receipt: recovered,
-			created: error.category !== "duplicate"
-		};
-		if (error.category === "duplicate") throw error;
-		throw unknownOutcomeError(error, `${orderNumber} rendelés`);
-	}
+	const run = async (recheck) => {
+		if (recheck || options.lookupFirst !== false) {
+			const existing = await lookup();
+			if (existing) return {
+				receipt: existing,
+				created: false
+			};
+		}
+		try {
+			return {
+				receipt: await api.create({
+					...input,
+					orderNumber,
+					callId
+				}, options),
+				created: true
+			};
+		} catch (error) {
+			if (!isUncertainOutcome(error)) throw error;
+			const state = {};
+			const recovered = await recoverAfterFailure(lookup, delayMs, options.signal, state);
+			if (recovered) return {
+				receipt: recovered,
+				created: error.category !== "duplicate"
+			};
+			if (error.category === "duplicate" && !state.lookupError) throw error;
+			throw unknownOutcomeError(error, `${orderNumber} rendelés`, { lookupError: state.lookupError });
+		}
+	};
+	return guardOnce(guard, `receipt:order:${orderNumber}`, options, run, (result) => ({
+		...result,
+		created: false
+	}));
 }
 //#endregion
-export { INVOICE_TEMPLATES as a, AGENT_ACTIONS as c, resolveInvoice as i, MAX_INVOICE_ATTACHMENTS as l, optionalAgentDate as n, TAXPAYER_TYPE_CODES as o, presentText as r, emitDocumentEvent as s, createReceiptOnce as t, SZAMLAZZ_AGENT_URL as u };
+export { SZAMLAZZ_AGENT_URL as _, registerPayment as a, resolveInvoice as c, TAXPAYER_TYPE_CODES as d, DocumentHookError as f, MAX_INVOICE_ATTACHMENTS as g, AGENT_ACTIONS as h, clearPayments as i, INVOICE_LANGUAGES as l, isDocumentHookError as m, paymentMarker as n, optionalAgentDate as o, emitDocumentEvent as p, registerPaymentOnce as r, presentText as s, createReceiptOnce as t, INVOICE_TEMPLATES as u };

package/dist/create-once-VKp0tVow.d.ts

@@ -0,0 +1,20 @@
+import { G as InvoiceType, N as CreatedInvoice } from "./context-kb33TgzE.js";
+import { r as Receipt } from "./types-D1zDOH_F.js";
+import { n as InvoiceDetails } from "./get-Byc9T5WO.js";
+//#region src/invoices/create-once.d.ts
+interface InvoiceOnceResult {
+  readonly number: string;
+  readonly created: boolean;
+  readonly externalId: string;
+  readonly invoice?: CreatedInvoice | undefined;
+  readonly details?: InvoiceDetails | undefined;
+}
+declare function invoiceOnceExternalId(type: InvoiceType, orderNumber: string): string;
+//#endregion
+//#region src/receipts/create-once.d.ts
+interface ReceiptOnceResult {
+  readonly receipt: Receipt;
+  readonly created: boolean;
+}
+//#endregion
+export { InvoiceOnceResult as n, invoiceOnceExternalId as r, ReceiptOnceResult as t };

package/dist/{crypto-B8lERvR1.cjs → crypto-Dpn4FHQ6.cjs}

@@ -11,6 +11,9 @@ function bytesToHex(bytes) {
 	for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
 	return hex;
 }
+async function digestHex(algorithm, data) {
+	return bytesToHex(new Uint8Array(await crypto.subtle.digest(algorithm, toBytes(data))));
+}
 async function hmac(algorithm, key, data) {
 	const cryptoKey = await crypto.subtle.importKey("raw", toBytes(key), {
 		name: "HMAC",
@@ -36,6 +39,12 @@ Object.defineProperty(exports, "bytesToHex", {
 		return bytesToHex;
 	}
 });
+Object.defineProperty(exports, "digestHex", {
+	enumerable: true,
+	get: function() {
+		return digestHex;
+	}
+});
 Object.defineProperty(exports, "hmac", {
 	enumerable: true,
 	get: function() {

package/dist/{crypto-DK_osBVy.js → crypto-usDg8L2K.js}

@@ -11,6 +11,9 @@ function bytesToHex(bytes) {
 	for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
 	return hex;
 }
+async function digestHex(algorithm, data) {
+	return bytesToHex(new Uint8Array(await crypto.subtle.digest(algorithm, toBytes(data))));
+}
 async function hmac(algorithm, key, data) {
 	const cryptoKey = await crypto.subtle.importKey("raw", toBytes(key), {
 		name: "HMAC",
@@ -30,4 +33,4 @@ function timingSafeEqual(left, right) {
 	return difference === 0;
 }
 //#endregion
-export { timingSafeEqual as i, hmac as n, hmacHex as r, bytesToHex as t };
+export { timingSafeEqual as a, hmacHex as i, digestHex as n, hmac as r, bytesToHex as t };

package/dist/data-link/index.cjs

@@ -0,0 +1,232 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("../errors-EE96_6D_.cjs");
+const require_binary = require("../binary-B89HM03_.cjs");
+const require_serialize = require("../serialize-CquIsxA-.cjs");
+const require_parse = require("../parse-DOA2XQ3e.cjs");
+const require_get = require("../get-BdMTseh4.cjs");
+const require_crypto = require("../crypto-Dpn4FHQ6.cjs");
+const require_request_body = require("../request-body-CH6ZGOrq.cjs");
+//#region src/data-link/push.ts
+var DataLinkError = class extends Error {
+	name = "DataLinkError";
+	reason;
+	constructor(reason, message, cause) {
+		super(message, cause === void 0 ? void 0 : { cause });
+		this.reason = reason;
+	}
+};
+const ROOT_KINDS = /* @__PURE__ */ new Map([
+	["szamla", "invoice"],
+	["szamlabe", "incoming-invoice"],
+	["banktranz", "bank-transaction"],
+	["xmlnyugtaarchiv", "receipts"]
+]);
+function invalid(message, cause) {
+	return new DataLinkError("invalid_payload", message, cause);
+}
+function requiredText(element, name, path) {
+	const value = require_serialize.childText(element, name);
+	if (value === void 0) throw invalid(`Hiányzik a(z) <${path}/${name}> elem.`);
+	return value;
+}
+function requiredInteger(element, name, path) {
+	const value = Number(requiredText(element, name, path));
+	if (!Number.isInteger(value)) throw invalid(`A(z) <${path}/${name}> nem egész szám.`);
+	return value;
+}
+function wrapSzamlazzError(read) {
+	try {
+		return read();
+	} catch (error) {
+		if (error instanceof require_errors.SzamlazzError) throw invalid(error.message, error);
+		throw error;
+	}
+}
+function invoicePush(kind, root, raw, key) {
+	const header = require_serialize.findChild(root, "alap");
+	const id = requiredInteger(header, "id", "alap");
+	const response = require_parse.createAgentResponse("getInvoiceXml", 200, new Headers(), require_binary.encodeUtf8(raw));
+	return {
+		kind,
+		key,
+		raw,
+		id,
+		invoice: wrapSzamlazzError(() => require_get.parseInvoiceDetailsXml(root, response)),
+		deleted: require_serialize.childBoolean(header, "dobdel") === true
+	};
+}
+function bankTransactionPush(root, raw, key) {
+	const direction = requiredText(root, "irany", "banktranz");
+	if (direction !== "BE" && direction !== "KI") throw invalid(`Ismeretlen banki tranzakció irány: ${direction}.`);
+	const amount = require_serialize.childNumber(root, "osszeg");
+	if (amount === void 0) throw invalid("Hiányzik a(z) <banktranz/osszeg> elem.");
+	const partner = require_serialize.findChild(root, "partner");
+	return {
+		kind: "bank-transaction",
+		key,
+		raw,
+		transaction: {
+			id: requiredInteger(root, "id", "banktranz"),
+			accountNumber: requiredText(root, "bankszamla", "banktranz"),
+			valueDate: requiredText(root, "erteknap", "banktranz"),
+			direction: direction === "BE" ? "in" : "out",
+			type: require_serialize.childText(root, "tipus"),
+			technical: require_serialize.childBoolean(root, "technikai") === true,
+			amount,
+			currency: requiredText(root, "devizanem", "banktranz"),
+			partner: partner && {
+				name: require_serialize.childText(partner, "nev"),
+				accountNumber: require_serialize.childText(partner, "bankszamla")
+			},
+			reference: require_serialize.childText(root, "kozlemeny")
+		}
+	};
+}
+function receiptsPush(root, raw, key) {
+	const response = require_parse.createAgentResponse("getReceipt", 200, new Headers(), require_binary.encodeUtf8(raw));
+	const receipts = require_serialize.findChildren(root, "nyugta").map((element) => ({
+		receipt: wrapSzamlazzError(() => require_parse.parseReceiptElement(element, response)),
+		issuerTaxNumber: require_serialize.childText(require_serialize.findChild(element, "alap"), "adoszam")
+	}));
+	if (receipts.length === 0) throw invalid("A nyugtaarchívum nem tartalmaz <nyugta> elemet.");
+	return {
+		kind: "receipts",
+		key,
+		raw,
+		receipts
+	};
+}
+function parseDataLinkPush(xml, key) {
+	if (xml.trim() === "") throw invalid("Üres adatkapcsolati üzenet érkezett.");
+	let root;
+	try {
+		root = require_serialize.parseXml(xml);
+	} catch (error) {
+		if (error instanceof require_serialize.XmlParseError) throw invalid(`Az üzenet nem érvényes XML: ${error.message}`, error);
+		throw error;
+	}
+	const kind = ROOT_KINDS.get(root.name);
+	const normalizedKey = key?.trim() || void 0;
+	switch (kind) {
+		case "invoice":
+		case "incoming-invoice": return invoicePush(kind, root, xml, normalizedKey);
+		case "bank-transaction": return bankTransactionPush(root, xml, normalizedKey);
+		case "receipts": return receiptsPush(root, xml, normalizedKey);
+		default: throw new DataLinkError("unknown_document", `Ismeretlen adatkapcsolati bizonylattípus: <${root.name}>.`);
+	}
+}
+//#endregion
+//#region src/data-link/response.ts
+const DATA_LINK_RESPONSE_ROOTS = {
+	invoice: {
+		root: "szamlavalasz",
+		namespace: "http://www.szamlazz.hu/szamlavalasz"
+	},
+	"incoming-invoice": {
+		root: "szamlabevalasz",
+		namespace: "http://www.szamlazz.hu/szamlabevalasz"
+	},
+	"bank-transaction": {
+		root: "banktranzvalasz",
+		namespace: "http://www.szamlazz.hu/banktranzvalasz"
+	},
+	receipts: {
+		root: "nyugtavalasz",
+		namespace: "http://www.szamlazz.hu/nyugtavalasz"
+	}
+};
+function keyErrorOf(acknowledgement) {
+	const keyError = acknowledgement.keyError;
+	if (keyError === void 0 || keyError === "KEY_ERR" || keyError === "KEY_DEL") return keyError;
+	throw new TypeError(`Ismeretlen kulcshiba: ${String(keyError)}. Csak KEY_ERR vagy KEY_DEL adható.`);
+}
+function registrationNumberOf(push, value) {
+	if (value !== void 0 && typeof value !== "string") throw new TypeError("Az iktatószám (registrationNumber) szöveg legyen.");
+	const registrationNumber = value?.trim();
+	if (!registrationNumber) return void 0;
+	if (push.kind !== "invoice" && push.kind !== "incoming-invoice") throw new TypeError("Iktatószámot csak számla (kimenő vagy bejövő) válaszában lehet visszaadni.");
+	return registrationNumber;
+}
+function dataLinkResponseXml(push, acknowledgement = {}) {
+	const target = DATA_LINK_RESPONSE_ROOTS[push.kind];
+	const keyError = keyErrorOf(acknowledgement);
+	const registrationNumber = registrationNumberOf(push, acknowledgement.registrationNumber);
+	const children = [];
+	if (push.kind === "invoice" || push.kind === "incoming-invoice") children.push(require_serialize.el("alap", [require_serialize.el("id", push.id), require_serialize.optionalEl("iktatoszam", registrationNumber)]));
+	if (keyError !== void 0) children.push(require_serialize.el("hibakod", keyError));
+	return require_serialize.buildXmlDocument({
+		root: target.root,
+		namespace: target.namespace,
+		children
+	});
+}
+function dataLinkResponse(push, acknowledgement = {}) {
+	return new Response(dataLinkResponseXml(push, acknowledgement), {
+		status: 200,
+		headers: { "content-type": "application/xml; charset=UTF-8" }
+	});
+}
+//#endregion
+//#region src/data-link/handler.ts
+const DATA_LINK_KEY_HEADER = "x-szamlazzhu-key";
+const DEFAULT_DATA_LINK_MAX_BYTES = 67108864;
+function plain(status, body) {
+	return new Response(body, {
+		status,
+		headers: { "content-type": "text/plain; charset=utf-8" }
+	});
+}
+function reportError(onError, error) {
+	try {
+		if (onError) onError(error);
+		else console.error("[kassza] Az adatkapcsolati üzenet feldolgozása nem sikerült.", error);
+	} catch {
+		return;
+	}
+}
+function acknowledgementOf(value) {
+	if (value === void 0 || value === null) return {};
+	if (typeof value !== "object") throw new TypeError("Az onPush csak DataLinkAcknowledgement objektumot (registrationNumber, keyError) vagy semmit adhat vissza.");
+	return value;
+}
+function configuredKeys(keys) {
+	if (keys === void 0) return void 0;
+	const trimmed = keys.map((key) => typeof key === "string" ? key.trim() : "");
+	if (trimmed.length === 0 || trimmed.some((key) => key === "")) throw new TypeError("A keys lista nem lehet üres, és nem tartalmazhat üres kulcsot.");
+	return trimmed;
+}
+async function checkKey(options, keys, push) {
+	const key = push.key;
+	if (key === void 0) return "KEY_ERR";
+	if (keys !== void 0 && !keys.some((candidate) => require_crypto.timingSafeEqual(candidate, key))) return "KEY_ERR";
+	if (!options.verifyKey) return true;
+	const result = await options.verifyKey(key, push);
+	return result === false ? "KEY_ERR" : result;
+}
+function dataLinkHandler(options) {
+	if (typeof options.onPush !== "function") throw new TypeError("Add meg az onPush függvényt.");
+	const keys = configuredKeys(options.keys);
+	if (keys === void 0 && typeof options.verifyKey !== "function") throw new TypeError("Add meg az elfogadott azonosító kulcsokat (keys) vagy a verifyKey függvényt: az adatkapcsolati üzenetnek nincs aláírása, csak a kulcs azonosítja a küldőt.");
+	const maxBytes = options.maxBodyBytes ?? 67108864;
+	return async (request) => {
+		try {
+			const push = parseDataLinkPush(await require_request_body.readRequestText(request, maxBytes, () => new DataLinkError("payload_too_large", `Az adatkapcsolati üzenet nagyobb a megengedett ${maxBytes} bájtnál.`)), request.headers.get("x-szamlazzhu-key") ?? void 0);
+			const keyCheck = await checkKey(options, keys, push);
+			if (keyCheck !== true) return dataLinkResponse(push, { keyError: keyCheck });
+			return dataLinkResponse(push, acknowledgementOf(await options.onPush(push)));
+		} catch (error) {
+			if (error instanceof DataLinkError) return plain(400, error.message);
+			reportError(options.onError, error);
+			return plain(500, "Az adatkapcsolati üzenet feldolgozása nem sikerült.");
+		}
+	};
+}
+//#endregion
+exports.DATA_LINK_KEY_HEADER = DATA_LINK_KEY_HEADER;
+exports.DATA_LINK_RESPONSE_ROOTS = DATA_LINK_RESPONSE_ROOTS;
+exports.DEFAULT_DATA_LINK_MAX_BYTES = DEFAULT_DATA_LINK_MAX_BYTES;
+exports.DataLinkError = DataLinkError;
+exports.dataLinkHandler = dataLinkHandler;
+exports.dataLinkResponse = dataLinkResponse;
+exports.dataLinkResponseXml = dataLinkResponseXml;
+exports.parseDataLinkPush = parseDataLinkPush;

package/dist/data-link/index.d.cts

@@ -0,0 +1,29 @@
+import { a as DataLinkError, c as DataLinkPush, d as parseDataLinkPush, i as DataLinkBankTransactionPush, l as DataLinkPushKind, n as DataLinkBankTransaction, o as DataLinkErrorReason, r as DataLinkBankTransactionPartner, s as DataLinkInvoicePush, t as DataLinkArchivedReceipt, u as DataLinkReceiptsPush } from "../push-D4nNbCNV.cjs";
+//#region src/data-link/response.d.ts
+type DataLinkKeyError = "KEY_ERR" | "KEY_DEL";
+interface DataLinkAcknowledgement {
+  readonly registrationNumber?: string | undefined;
+  readonly keyError?: DataLinkKeyError | undefined;
+}
+export declare const DATA_LINK_RESPONSE_ROOTS: Readonly<Record<DataLinkPushKind, {
+  readonly root: string;
+  readonly namespace: string;
+}>>;
+export declare function dataLinkResponseXml(push: DataLinkPush, acknowledgement?: DataLinkAcknowledgement): string;
+export declare function dataLinkResponse(push: DataLinkPush, acknowledgement?: DataLinkAcknowledgement): Response;
+//#endregion
+//#region src/data-link/handler.d.ts
+export declare const DATA_LINK_KEY_HEADER = "x-szamlazzhu-key";
+export declare const DEFAULT_DATA_LINK_MAX_BYTES = 67108864;
+type DataLinkKeyCheck = boolean | DataLinkKeyError;
+interface DataLinkHandlerOptions {
+  readonly keys?: readonly string[] | undefined;
+  readonly verifyKey?: ((key: string, push: DataLinkPush) => DataLinkKeyCheck | Promise<DataLinkKeyCheck>) | undefined;
+  readonly onPush: (push: DataLinkPush) => unknown;
+  readonly onError?: ((error: unknown) => void) | undefined;
+  readonly maxBodyBytes?: number | undefined;
+}
+type DataLinkHandler = (request: Request) => Promise<Response>;
+export declare function dataLinkHandler(options: DataLinkHandlerOptions): DataLinkHandler;
+//#endregion
+export { type DataLinkAcknowledgement, type DataLinkArchivedReceipt, type DataLinkBankTransaction, type DataLinkBankTransactionPartner, type DataLinkBankTransactionPush, DataLinkError, type DataLinkErrorReason, type DataLinkHandler, type DataLinkHandlerOptions, type DataLinkInvoicePush, type DataLinkKeyCheck, type DataLinkKeyError, type DataLinkPush, type DataLinkPushKind, type DataLinkReceiptsPush, parseDataLinkPush };

package/dist/data-link/index.d.ts

@@ -0,0 +1,29 @@
+import { a as DataLinkError, c as DataLinkPush, d as parseDataLinkPush, i as DataLinkBankTransactionPush, l as DataLinkPushKind, n as DataLinkBankTransaction, o as DataLinkErrorReason, r as DataLinkBankTransactionPartner, s as DataLinkInvoicePush, t as DataLinkArchivedReceipt, u as DataLinkReceiptsPush } from "../push-BXj0Sf0Z.js";
+//#region src/data-link/response.d.ts
+type DataLinkKeyError = "KEY_ERR" | "KEY_DEL";
+interface DataLinkAcknowledgement {
+  readonly registrationNumber?: string | undefined;
+  readonly keyError?: DataLinkKeyError | undefined;
+}
+export declare const DATA_LINK_RESPONSE_ROOTS: Readonly<Record<DataLinkPushKind, {
+  readonly root: string;
+  readonly namespace: string;
+}>>;
+export declare function dataLinkResponseXml(push: DataLinkPush, acknowledgement?: DataLinkAcknowledgement): string;
+export declare function dataLinkResponse(push: DataLinkPush, acknowledgement?: DataLinkAcknowledgement): Response;
+//#endregion
+//#region src/data-link/handler.d.ts
+export declare const DATA_LINK_KEY_HEADER = "x-szamlazzhu-key";
+export declare const DEFAULT_DATA_LINK_MAX_BYTES = 67108864;
+type DataLinkKeyCheck = boolean | DataLinkKeyError;
+interface DataLinkHandlerOptions {
+  readonly keys?: readonly string[] | undefined;
+  readonly verifyKey?: ((key: string, push: DataLinkPush) => DataLinkKeyCheck | Promise<DataLinkKeyCheck>) | undefined;
+  readonly onPush: (push: DataLinkPush) => unknown;
+  readonly onError?: ((error: unknown) => void) | undefined;
+  readonly maxBodyBytes?: number | undefined;
+}
+type DataLinkHandler = (request: Request) => Promise<Response>;
+export declare function dataLinkHandler(options: DataLinkHandlerOptions): DataLinkHandler;
+//#endregion
+export { type DataLinkAcknowledgement, type DataLinkArchivedReceipt, type DataLinkBankTransaction, type DataLinkBankTransactionPartner, type DataLinkBankTransactionPush, DataLinkError, type DataLinkErrorReason, type DataLinkHandler, type DataLinkHandlerOptions, type DataLinkInvoicePush, type DataLinkKeyCheck, type DataLinkKeyError, type DataLinkPush, type DataLinkPushKind, type DataLinkReceiptsPush, parseDataLinkPush };