kassza 0.12.0 → 0.13.0

package/dist/testing/index.js

@@ -1,8 +1,1479 @@
-import { i as resolveInvoice, s as emitDocumentEvent, t as createReceiptOnce } from "../create-once-CqdYmQD8.js";
-import { n as SzamlazzError } from "../errors-DLrb0g64.js";
-import { _ as createInvoiceOnce, a as calculateReceiptItems, i as buildCreateReceiptXml, m as convertReceiptToInvoice, n as issueForPayment } from "../issue-C6Fcjvln.js";
-import { n as toAgentDate } from "../dates-CXyj7Azy.js";
-import { i as summarizeItems } from "../money-DAA7OwiO.js";
+import { c as emitDocumentEvent, i as resolveInvoice, l as AGENT_ACTIONS, t as createReceiptOnce } from "../create-once-Cz621l8r.js";
+import { n as SzamlazzError, t as AGENT_ERROR_CODES } from "../errors-DLrb0g64.js";
+import { i as encodeUtf8, n as bytesToBase64 } from "../binary-D0M9U2MD.js";
+import { a as optionalEl, c as childNumber, d as findChildren, f as parseXml, i as formatXmlNumber, l as childText, n as buildXmlDocument, r as el, s as childBoolean, u as findChild } from "../serialize-DSE_o9RK.js";
+import { n as toAgentDate, r as toBudapestDate } from "../dates-CXyj7Azy.js";
+import { n as decimalPlaces, r as roundMoney } from "../rounding-BLyHjjI5.js";
+import { i as isHuf, t as NUMERIC_VAT_RATES } from "../vat-v_dcWCto.js";
+import { i as summarizeItems } from "../money-t7uy1n91.js";
+import { _ as createInvoiceOnce, a as calculateReceiptItems, i as buildCreateReceiptXml, n as issueForPayment, p as convertReceiptToInvoice } from "../issue-DtSLpVdJ.js";
+//#region src/testing/fake-agent-http.ts
+const XML_CONTENT_TYPE = "application/xml; charset=UTF-8";
+const TEXT_CONTENT_TYPE = "text/plain; charset=UTF-8";
+const PDF_CONTENT_TYPE = "application/pdf";
+const ERROR_ROOTS = {
+	invoice: "xmlszamlavalasz",
+	receipt: "xmlnyugtavalasz",
+	"receipt-send": "xmlnyugtasendvalasz",
+	proforma: "xmlszamladbkdelvalasz"
+};
+function encodeHeaderValue(value) {
+	return encodeURIComponent(value).replace(/%20/g, "+");
+}
+function xmlResponse(xml, headers = {}) {
+	return {
+		status: 200,
+		headers: {
+			"content-type": XML_CONTENT_TYPE,
+			...headers
+		},
+		body: xml
+	};
+}
+function textResponse(text, headers = {}, status = 200) {
+	return {
+		status,
+		headers: {
+			"content-type": TEXT_CONTENT_TYPE,
+			...headers
+		},
+		body: text
+	};
+}
+function pdfResponse(pdf, headers = {}) {
+	return {
+		status: 200,
+		headers: {
+			"content-type": PDF_CONTENT_TYPE,
+			...headers
+		},
+		body: pdf
+	};
+}
+function serverErrorResponse() {
+	return {
+		status: 500,
+		headers: { "content-type": "text/html; charset=UTF-8" },
+		body: "<!DOCTYPE html><html><body><h1>500 Internal Server Error</h1></body></html>"
+	};
+}
+function namespaceOf(root) {
+	return `http://www.szamlazz.hu/${root}`;
+}
+function xmlDocument(root, children) {
+	return buildXmlDocument({
+		root,
+		namespace: namespaceOf(root),
+		children
+	});
+}
+function errorHeaders(failure) {
+	return {
+		szlahu_error: encodeHeaderValue(failure.message),
+		...failure.code === void 0 ? {} : { szlahu_error_code: String(failure.code) }
+	};
+}
+function errorText(failure) {
+	return `[ERR] ${failure.code === void 0 ? "" : `[${failure.code}] `}${failure.message}\n----------\nkassza hamis Agent\n`;
+}
+function errorResponse(style, failure) {
+	if (style === "text") return textResponse(errorText(failure), errorHeaders(failure));
+	return xmlResponse(xmlDocument(ERROR_ROOTS[style], [
+		el("sikeres", false),
+		optionalEl("hibakod", failure.code),
+		el("hibauzenet", failure.message)
+	]), style === "invoice" ? errorHeaders(failure) : {});
+}
+function invoiceResultHeaders(fields) {
+	const headers = {};
+	if (fields.number !== void 0) headers.szlahu_szamlaszam = encodeHeaderValue(fields.number);
+	if (fields.netTotal !== void 0) headers.szlahu_nettovegosszeg = formatXmlNumber(fields.netTotal);
+	if (fields.grossTotal !== void 0) headers.szlahu_bruttovegosszeg = formatXmlNumber(fields.grossTotal);
+	if (fields.outstanding !== void 0) headers.szlahu_kintlevoseg = formatXmlNumber(fields.outstanding);
+	if (fields.paymentMethod !== void 0) headers.szlahu_fizetesmod = encodeHeaderValue(fields.paymentMethod);
+	return headers;
+}
+function invoiceResultResponse(fields, version) {
+	const headers = invoiceResultHeaders(fields);
+	if (version === 2) return xmlResponse(xmlDocument("xmlszamlavalasz", [
+		el("sikeres", true),
+		optionalEl("szamlaszam", fields.number),
+		optionalEl("szamlanetto", fields.netTotal),
+		optionalEl("szamlabrutto", fields.grossTotal),
+		optionalEl("kintlevoseg", fields.outstanding),
+		optionalEl("pdf", fields.pdf && bytesToBase64(fields.pdf))
+	]), headers);
+	if (fields.pdf) return pdfResponse(fields.pdf, headers);
+	return textResponse(`xmlagentresponse=DONE${fields.number === void 0 ? "" : `;${fields.number}`}\n`, headers);
+}
+function toFetchResponse(response) {
+	const body = typeof response.body === "string" ? response.body : new Blob([response.body]);
+	return new Response(body, {
+		status: response.status,
+		headers: response.headers
+	});
+}
+//#endregion
+//#region src/testing/fake-agent-state.ts
+var FakeAgentFailure = class extends Error {
+	name = "FakeAgentFailure";
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+function agentFailure(code, message) {
+	return new FakeAgentFailure(code, message ?? AGENT_ERROR_CODES[code]?.message ?? `Hiba (${code}).`);
+}
+function nextCounter(state, key) {
+	const next = (state.counters.get(key) ?? 0) + 1;
+	state.counters.set(key, next);
+	return next;
+}
+function today(state) {
+	return toBudapestDate(state.now());
+}
+function nextDocumentNumber(state, series) {
+	const year = today(state).slice(0, 4);
+	return `${series}-${year}-${nextCounter(state, `${series}|${year}`)}`;
+}
+function nextDocumentId(state) {
+	return nextCounter(state, "#id");
+}
+function fakePdf(label) {
+	return encodeUtf8(`%PDF-1.4\n%kassza hamis Agent: ${label}\n%%EOF\n`);
+}
+function taxpayerKey(value) {
+	return value.replace(/\D/g, "").slice(0, 8);
+}
+//#endregion
+//#region src/testing/fake-agent-items.ts
+const SERVER_VAT_CODES = /* @__PURE__ */ new Set([
+	"TAM",
+	"AAM",
+	"EU",
+	"EUK",
+	"MAA",
+	"F.AFA",
+	"K.AFA",
+	"ÁKK",
+	"TAHK",
+	"TEHK",
+	"EUT",
+	"EUKT",
+	"HO",
+	"EUE",
+	"EUFADE",
+	"EUFAD37",
+	"ATK",
+	"NAM",
+	"EAM",
+	"KBAUK",
+	"KBAET"
+]);
+const NUMERIC_RATES = new Set(NUMERIC_VAT_RATES);
+const AMOUNT_FIELDS = {
+	invoice: {
+		net: "nettoErtek",
+		vat: "afaErtek",
+		gross: "bruttoErtek"
+	},
+	receipt: {
+		net: "netto",
+		vat: "afa",
+		gross: "brutto"
+	}
+};
+const HUF_TOLERANCE = 2;
+const FOREIGN_TOLERANCE = .02;
+const SUM_EPSILON = 1e-6;
+const RECEIPT_DECIMALS = 2;
+const TOTAL_DECIMALS = 6;
+function xmlFailure(detail) {
+	return new FakeAgentFailure(57, `XML beolvasási hiba: ${detail}`);
+}
+function requiredText$2(element, name, position) {
+	const value = childText(element, name);
+	if (value === void 0) throw xmlFailure(`hiányzik a(z) ${position}. tétel <${name}> eleme.`);
+	return value;
+}
+function requiredNumber(element, name, position) {
+	const value = childNumber(element, name);
+	if (value === void 0) throw xmlFailure(`a(z) ${position}. tétel <${name}> eleme hiányzik vagy nem szám.`);
+	return value;
+}
+function parseVat(raw, itemName) {
+	const numeric = Number(raw.replace(",", "."));
+	if (Number.isFinite(numeric) && NUMERIC_RATES.has(numeric)) return { rate: numeric };
+	if (SERVER_VAT_CODES.has(raw)) return {
+		rate: 0,
+		code: raw
+	};
+	throw new FakeAgentFailure(395, `Érvénytelen áfakulcs: ${raw}. Termék: ${itemName}`);
+}
+function ledgerOf(element) {
+	const revenue = childText(element, "arbevetel");
+	const vat = childText(element, "afa");
+	return revenue === void 0 && vat === void 0 ? void 0 : {
+		revenue,
+		vat
+	};
+}
+function parseItem(element, kind, position) {
+	const fields = AMOUNT_FIELDS[kind];
+	const name = requiredText$2(element, "megnevezes", position);
+	const vat = parseVat(requiredText$2(element, "afakulcs", position), name);
+	return {
+		name,
+		identifier: childText(element, "azonosito"),
+		quantity: requiredNumber(element, "mennyiseg", position),
+		unit: requiredText$2(element, "mennyisegiEgyseg", position),
+		netUnitPrice: requiredNumber(element, "nettoEgysegar", position),
+		vatRate: vat.rate,
+		vatCode: vat.code,
+		netAmount: requiredNumber(element, fields.net, position),
+		vatAmount: requiredNumber(element, fields.vat, position),
+		grossAmount: requiredNumber(element, fields.gross, position),
+		comment: childText(element, "megjegyzes"),
+		ledger: kind === "receipt" ? ledgerOf(findChild(element, "fokonyv")) : void 0
+	};
+}
+function parseItems(root, kind) {
+	const elements = findChildren(findChild(root, "tetelek"), "tetel");
+	if (elements.length === 0) throw xmlFailure("legalább egy tételt (<tetel>) meg kell adni.");
+	return elements.map((element, index) => parseItem(element, kind, index + 1));
+}
+function amountFailure(code, item) {
+	return new FakeAgentFailure(code, `${{
+		259: "A tétel nettó értéke nem megfelelő; nettó érték = nettó egységár x mennyiség.",
+		260: "A tétel áfa értéke nem megfelelő; áfa érték = tétel nettó értéke x áfakulcs mértéke / 100.",
+		261: "A tétel bruttó értéke nem megfelelő; bruttó érték = tétel nettó értéke + tétel áfa értéke.",
+		363: "A tétel bruttó értékének egész számnak kell lennie.",
+		364: "A tétel nettó értéke maximum 2 tizedes jegyet tartalmazhat.",
+		365: "A tétel áfa értéke maximum 2 tizedes jegyet tartalmazhat."
+	}[code] ?? "Hibás tételösszeg."} Termék: ${item.name}`);
+}
+function netMismatch(item, tolerance) {
+	return Math.abs(item.netUnitPrice * item.quantity - item.netAmount) > tolerance;
+}
+function vatMismatch(item, tolerance) {
+	return Math.abs(item.netAmount * item.vatRate / 100 - item.vatAmount) > tolerance;
+}
+function grossMismatch(item) {
+	return Math.abs(item.netAmount + item.vatAmount - item.grossAmount) > SUM_EPSILON;
+}
+function assertInvoiceItems(items, currency, hasMarginVat) {
+	const tolerance = isHuf(currency) ? HUF_TOLERANCE : FOREIGN_TOLERANCE;
+	items.forEach((item, index) => {
+		if (netMismatch(item, tolerance)) throw amountFailure(259, item);
+		if (!hasMarginVat(index) && vatMismatch(item, tolerance)) throw amountFailure(260, item);
+		if (grossMismatch(item)) throw amountFailure(261, item);
+	});
+}
+function assertReceiptItems(items, currency) {
+	if (!isHuf(currency)) return;
+	for (const item of items) {
+		if (grossMismatch(item)) throw amountFailure(261, item);
+		if (!Number.isInteger(item.grossAmount)) throw amountFailure(363, item);
+		if (decimalPlaces(item.netAmount) > RECEIPT_DECIMALS) throw amountFailure(364, item);
+		if (decimalPlaces(item.vatAmount) > RECEIPT_DECIMALS) throw amountFailure(365, item);
+		if (netMismatch(item, HUF_TOLERANCE)) throw amountFailure(259, item);
+		if (vatMismatch(item, HUF_TOLERANCE)) throw amountFailure(260, item);
+	}
+}
+function sum(values) {
+	return roundMoney(values.reduce((total, value) => total + value, 0), TOTAL_DECIMALS);
+}
+function totalsOf(items) {
+	return {
+		net: sum(items.map((item) => item.netAmount)),
+		vat: sum(items.map((item) => item.vatAmount)),
+		gross: sum(items.map((item) => item.grossAmount))
+	};
+}
+function vatGroupsOf(items) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = `${item.vatCode ?? ""}|${item.vatRate}`;
+		groups.set(key, [...groups.get(key) ?? [], item]);
+	}
+	return [...groups.values()].flatMap((group) => {
+		const [first] = group;
+		if (!first) return [];
+		const totals = totalsOf(group);
+		return [{
+			vatRate: first.vatRate,
+			vatCode: first.vatCode,
+			net: totals.net,
+			vat: totals.vat,
+			gross: totals.gross
+		}];
+	});
+}
+function negateItem(item) {
+	return {
+		...item,
+		quantity: -item.quantity,
+		netAmount: -item.netAmount,
+		vatAmount: -item.vatAmount,
+		grossAmount: -item.grossAmount
+	};
+}
+function negateTotals(totals) {
+	return {
+		net: -totals.net,
+		vat: -totals.vat,
+		gross: -totals.gross
+	};
+}
+function outstandingOf(gross, paid) {
+	return gross > 0 ? Math.max(0, sum([gross, -paid])) : 0;
+}
+//#endregion
+//#region src/testing/fake-agent-account.ts
+const NAV_API_NAMESPACE = "http://schemas.nav.gov.hu/OSA/3.0/api";
+const TAXPAYER_ID_PATTERN = /^\d{8}$/;
+const CONNECT_PRINCIPAL_MESSAGES = {
+	created: "DONE",
+	ownerInviteResent: "Már létező fiók, nincs fiókgazdája. Fiókgazdai meghívó (megbízott számlakibocsátás) email újraküldve.",
+	joinRequestSent: "Már létező fiók fiókgazdával. Csatlakozási kérelmet küldtünk a fiókgazdának.",
+	joinRequestResent: "Már létező fiók fiókgazdával. A csatlakozási kérelem emailt újraküldtük a fiókgazdának."
+};
+function authenticateDelegate(state, username, password) {
+	const delegate = state.delegates.get(username);
+	if (!delegate) return false;
+	if (delegate.password !== password || !delegate.approved) throw agentFailure(3);
+	if (state.principals.get(delegate.taxpayerId)?.state !== "owned") throw agentFailure(250);
+	return true;
+}
+function authenticate(state, credentials) {
+	const { agentKey, username, password } = credentials;
+	if (agentKey !== void 0) {
+		if (!state.config.strictAuth || state.config.agentKeys.has(agentKey)) return;
+		throw agentFailure(3);
+	}
+	if (username === void 0 || password === void 0) throw agentFailure(3);
+	if (authenticateDelegate(state, username, password)) return;
+	if (!state.config.strictAuth || state.users.get(username) === password) return;
+	throw agentFailure(3);
+}
+function acceptDelegation(state, taxNumber) {
+	const key = taxpayerKey(taxNumber);
+	const principal = state.principals.get(key);
+	if (!principal) throw new TypeError(`Nincs ilyen megbízói fiók a hamis Agentben: ${taxNumber}`);
+	state.principals.set(key, {
+		...principal,
+		state: "owned"
+	});
+	for (const [email, delegate] of state.delegates) if (delegate.taxpayerId === key) state.delegates.set(email, {
+		...delegate,
+		approved: true
+	});
+}
+function addressNode(taxpayer) {
+	const { address } = taxpayer;
+	if (!address) return void 0;
+	return el("taxpayerAddressList", [el("taxpayerAddressItem", [el("taxpayerAddressType", "HQ"), el("taxpayerAddress", [
+		el("countryCode", "HU"),
+		el("postalCode", address.postalCode),
+		el("city", address.city),
+		optionalEl("streetName", address.streetName),
+		optionalEl("publicPlaceCategory", address.publicPlaceCategory),
+		optionalEl("number", address.number)
+	])])]);
+}
+function taxpayerDataNode(taxpayerId, taxpayer) {
+	return el("taxpayerData", [
+		el("taxpayerName", taxpayer.name),
+		optionalEl("taxpayerShortName", taxpayer.shortName),
+		el("taxNumberDetail", [
+			el("taxpayerId", taxpayerId),
+			optionalEl("vatCode", taxpayer.vatCode),
+			optionalEl("countyCode", taxpayer.countyCode)
+		]),
+		optionalEl("incorporation", taxpayer.incorporation),
+		addressNode(taxpayer)
+	]);
+}
+function handleQueryTaxpayer(state, request) {
+	const taxpayerId = childText(request.root, "torzsszam");
+	if (taxpayerId === void 0 || !TAXPAYER_ID_PATTERN.test(taxpayerId)) throw xmlFailure("a <torzsszam> elemben 8 jegyű adószám-törzsszám kell.");
+	const taxpayer = state.config.taxpayers[taxpayerId];
+	const valid = taxpayer !== void 0 && taxpayer.valid !== false;
+	const timestamp = state.now().toISOString();
+	return xmlResponse(buildXmlDocument({
+		root: "QueryTaxpayerResponse",
+		namespace: NAV_API_NAMESPACE,
+		children: [
+			el("header", [
+				el("requestId", `KASSZAFAKE${nextCounter(state, "#nav")}`),
+				el("timestamp", timestamp),
+				el("requestVersion", "3.0"),
+				el("headerVersion", "1.0")
+			]),
+			el("result", [el("funcCode", "OK")]),
+			el("infoDate", timestamp),
+			el("taxpayerValidity", valid),
+			valid && taxpayer && taxpayerDataNode(taxpayerId, taxpayer)
+		]
+	}));
+}
+function connectResponse(message) {
+	const encoded = encodeHeaderValue(message);
+	return textResponse(`xmlagentresponse=${encoded}\n`, { XML_AGENT_RESPONSE: encoded });
+}
+function handleConnectPrincipal(state, request) {
+	const company = findChild(request.root, "cegMb");
+	const user = findChild(request.root, "usrMb");
+	const taxNumber = childText(company, "cegtaxnumber");
+	if (taxNumber === void 0) throw xmlFailure("hiányzik a(z) <cegMb/cegtaxnumber> elem.");
+	const key = taxpayerKey(taxNumber);
+	const principal = state.principals.get(key);
+	const email = childText(user, "usremail");
+	const password = childText(user, "usrpassword");
+	if (email === void 0 || password === void 0) throw xmlFailure("hiányzik a(z) <usrMb/usremail> vagy <usrMb/usrpassword> elem.");
+	if (!principal) {
+		state.principals.set(key, {
+			state: "unowned",
+			joinRequests: 0
+		});
+		state.delegates.set(email, {
+			taxpayerId: key,
+			password,
+			approved: true
+		});
+		return connectResponse(CONNECT_PRINCIPAL_MESSAGES.created);
+	}
+	if (principal.state === "unowned") return connectResponse(CONNECT_PRINCIPAL_MESSAGES.ownerInviteResent);
+	if (!state.delegates.has(email)) state.delegates.set(email, {
+		taxpayerId: key,
+		password,
+		approved: false
+	});
+	state.principals.set(key, {
+		...principal,
+		joinRequests: principal.joinRequests + 1
+	});
+	return connectResponse(principal.joinRequests === 0 ? CONNECT_PRINCIPAL_MESSAGES.joinRequestSent : CONNECT_PRINCIPAL_MESSAGES.joinRequestResent);
+}
+//#endregion
+//#region src/testing/fake-agent-invoice-xml.ts
+const UNIFIED_PAYMENT_METHODS = [
+	"átutalás",
+	"készpénz",
+	"bankkártya",
+	"csekk",
+	"utánvét",
+	"ajándékutalvány",
+	"barion",
+	"barter",
+	"csoportos beszedés",
+	"OTP Simple",
+	"kompenzáció",
+	"kupon",
+	"PayPal",
+	"PayU",
+	"SZÉP kártya",
+	"utalvány",
+	"MasterCard Mobile",
+	"Borgun",
+	"EP kártya",
+	"térítésmentes",
+	"egyéb"
+];
+const OTHER_PAYMENT_METHOD = "egyéb";
+const CASH_PAYMENT_METHOD = "készpénz";
+const SELLER_ID = 1;
+const DOMESTIC_LOCATION = 1;
+const PAPER_APPEARANCE = 0;
+const E_INVOICE_APPEARANCE = 2;
+function unifiedPaymentMethod(method) {
+	const normalized = method.trim().toLowerCase();
+	return UNIFIED_PAYMENT_METHODS.find((candidate) => candidate.toLowerCase() === normalized) ?? OTHER_PAYMENT_METHOD;
+}
+function sellerNode(invoice) {
+	const { seller } = invoice;
+	return el("szallito", [
+		el("id", SELLER_ID),
+		el("nev", seller.name),
+		el("cim", [
+			optionalEl("orszag", seller.country),
+			el("irsz", seller.zip),
+			el("telepules", seller.city),
+			el("cim", seller.address)
+		]),
+		el("adoszam", seller.taxNumber),
+		optionalEl("bank", [optionalEl("nev", seller.bankName), optionalEl("bankszamla", seller.bankAccount)])
+	]);
+}
+function headerNode(invoice, testAccount) {
+	const unified = unifiedPaymentMethod(invoice.paymentMethod);
+	return el("alap", [
+		el("id", invoice.id),
+		el("szamlaszam", invoice.number),
+		el("gazdEsemAzon", invoice.id),
+		el("tipus", invoice.typeCode),
+		el("eszamla", invoice.eInvoice ? E_INVOICE_APPEARANCE : PAPER_APPEARANCE),
+		optionalEl("hivszamlaszam", invoice.referencedInvoiceNumber),
+		optionalEl("hivdijbekszam", invoice.referencedProformaNumber),
+		el("kelt", invoice.issueDate),
+		el("telj", invoice.fulfillmentDate),
+		el("fizh", invoice.dueDate),
+		el("fizmod", invoice.paymentMethod),
+		el("fizmodunified", unified),
+		el("keszpenz", unified === CASH_PAYMENT_METHOD),
+		optionalEl("rendelesszam", invoice.orderNumber),
+		el("nyelv", invoice.language),
+		el("devizanem", invoice.currency),
+		optionalEl("devizabank", invoice.exchangeBank),
+		optionalEl("devizaarf", invoice.exchangeRate),
+		optionalEl("megjegyzes", invoice.comment),
+		el("penzforg", false),
+		el("kata", false),
+		el("katafokonyv", false),
+		optionalEl("email", invoice.buyer.email),
+		el("teszt", testAccount),
+		el("sztornozott", invoice.reversed)
+	]);
+}
+function buyerNode(invoice) {
+	const { buyer } = invoice;
+	return el("vevo", [
+		el("nev", buyer.name),
+		optionalEl("azonosito", buyer.identifier),
+		el("cim", [
+			optionalEl("orszag", buyer.country),
+			el("irsz", buyer.zip),
+			el("telepules", buyer.city),
+			el("cim", buyer.address)
+		]),
+		optionalEl("email", buyer.email),
+		el("adoszam", buyer.taxNumber ?? ""),
+		optionalEl("csoportazonosito", buyer.groupTaxNumber),
+		optionalEl("adoszameu", buyer.euTaxNumber),
+		el("lokacio", DOMESTIC_LOCATION),
+		el("privatePersonIndicator", buyer.taxNumber === void 0 && buyer.euTaxNumber === void 0)
+	]);
+}
+function itemNode$1(item, index) {
+	return el("tetel", [
+		el("nev", item.name),
+		optionalEl("azonosito", item.identifier),
+		el("mennyiseg", item.quantity),
+		el("mennyisegiegyseg", item.unit),
+		el("nettoegysegar", item.netUnitPrice),
+		optionalEl("afatipus", item.vatCode),
+		el("afakulcs", item.vatRate),
+		el("netto", item.netAmount),
+		el("afa", item.vatAmount),
+		el("brutto", item.grossAmount),
+		optionalEl("megjegyzes", item.comment),
+		el("sztetordering", index + 1)
+	]);
+}
+function vatGroupNode(group) {
+	return el("afakulcsossz", [
+		optionalEl("afatipus", group.vatCode),
+		el("afakulcs", group.vatRate),
+		el("netto", group.net),
+		el("afa", group.vat),
+		el("brutto", group.gross)
+	]);
+}
+function totalNode(totals) {
+	return el("totalossz", [
+		el("netto", totals.net),
+		el("afa", totals.vat),
+		el("brutto", totals.gross)
+	]);
+}
+function paymentNode$1(payment) {
+	return el("kifizetes", [
+		el("datum", payment.date),
+		el("jogcim", payment.method),
+		el("osszeg", payment.amount),
+		optionalEl("megjegyzes", payment.comment)
+	]);
+}
+function renderInvoiceXml(invoice, testAccount, includePdf) {
+	return buildXmlDocument({
+		root: "szamla",
+		namespace: "http://www.szamlazz.hu/szamla",
+		children: [
+			sellerNode(invoice),
+			headerNode(invoice, testAccount),
+			buyerNode(invoice),
+			el("tetelek", invoice.items.map(itemNode$1)),
+			el("osszegek", [...vatGroupsOf(invoice.items).map(vatGroupNode), totalNode(invoice.totals)]),
+			invoice.payments.length > 0 && el("kifizetesek", invoice.payments.map(paymentNode$1)),
+			includePdf && el("pdf", bytesToBase64(fakePdf(invoice.number)))
+		]
+	});
+}
+//#endregion
+//#region src/testing/fake-agent-request.ts
+const REQUEST_ROOTS = {
+	createInvoice: "xmlszamla",
+	reverseInvoice: "xmlszamlast",
+	registerPayment: "xmlszamlakifiz",
+	getInvoicePdf: "xmlszamlapdf",
+	getInvoiceXml: "xmlszamlaxml",
+	deleteProforma: "xmlszamladbkdel",
+	createReceipt: "xmlnyugtacreate",
+	reverseReceipt: "xmlnyugtast",
+	getReceipt: "xmlnyugtaget",
+	sendReceipt: "xmlnyugtasend",
+	queryTaxpayer: "xmltaxpayer",
+	connectPrincipal: "XmlCegMb"
+};
+const MAX_ATTACHMENTS = 5;
+const ACTION_FIELDS = Object.entries(AGENT_ACTIONS);
+async function readForm(input, init) {
+	if (init?.body instanceof FormData) return init.body;
+	try {
+		return await (input instanceof Request && init === void 0 ? input : new Request(input, init)).formData();
+	} catch {
+		return;
+	}
+}
+async function entryText(value) {
+	return typeof value === "string" ? value : value.text();
+}
+function attachmentsOf(form) {
+	const attachments = [];
+	for (let index = 1; index <= MAX_ATTACHMENTS; index++) {
+		const value = form.get(`attachfile${index}`);
+		if (value instanceof Blob) attachments.push({
+			filename: value instanceof File ? value.name : "",
+			size: value.size
+		});
+	}
+	return attachments;
+}
+async function readFakeAgentForm(input, init) {
+	const form = await readForm(input, init);
+	if (!form) return {
+		action: void 0,
+		xml: void 0,
+		attachments: []
+	};
+	for (const [action, field] of ACTION_FIELDS) {
+		const value = form.get(field);
+		if (value !== null) return {
+			action,
+			xml: await entryText(value),
+			attachments: attachmentsOf(form)
+		};
+	}
+	return {
+		action: void 0,
+		xml: void 0,
+		attachments: attachmentsOf(form)
+	};
+}
+function parseFakeAgentRequest(action, xml, attachments) {
+	let root;
+	try {
+		root = parseXml(xml);
+	} catch (error) {
+		throw new FakeAgentFailure(57, `XML beolvasási hiba.${error instanceof Error ? ` ${error.message}` : ""}`);
+	}
+	const expected = REQUEST_ROOTS[action];
+	if (root.name !== expected) throw new FakeAgentFailure(57, `XML beolvasási hiba. A(z) ${action} művelethez <${expected}> gyökérelem kell, érkezett: <${root.name}>.`);
+	return {
+		action,
+		xml,
+		root,
+		attachments
+	};
+}
+function credentialsOf(root) {
+	for (const holder of [
+		findChild(root, "login"),
+		findChild(root, "beallitasok"),
+		root
+	]) {
+		const agentKey = childText(holder, "szamlaagentkulcs");
+		const username = childText(holder, "felhasznalo") ?? childText(holder, "loginname");
+		const password = childText(holder, "jelszo") ?? childText(holder, "password");
+		if (agentKey !== void 0 || username !== void 0 || password !== void 0) return {
+			agentKey,
+			username,
+			password
+		};
+	}
+	return {};
+}
+function responseVersion(root) {
+	return childNumber(findChild(root, "beallitasok"), "valaszVerzio") ?? childNumber(root, "valaszVerzio") ?? 1;
+}
+function errorStyleFor(action, root) {
+	switch (action) {
+		case "createInvoice":
+		case "reverseInvoice":
+		case "registerPayment":
+		case "getInvoicePdf": return root !== void 0 && responseVersion(root) === 2 ? "invoice" : "text";
+		case "getInvoiceXml": return "invoice";
+		case "deleteProforma": return "proforma";
+		case "createReceipt":
+		case "reverseReceipt":
+		case "getReceipt": return "receipt";
+		case "sendReceipt": return "receipt-send";
+		case "queryTaxpayer":
+		case "connectPrincipal": return "text";
+	}
+}
+//#endregion
+//#region src/testing/fake-agent-invoices.ts
+const LANGUAGES = /* @__PURE__ */ new Set([
+	"hu",
+	"en",
+	"de",
+	"it",
+	"ro",
+	"sk",
+	"hr",
+	"fr",
+	"es",
+	"cz",
+	"pl",
+	"bg",
+	"nl",
+	"ru",
+	"si"
+]);
+const DUPLICATE_WINDOW_MS = 1728e5;
+const MAX_PAYMENTS = 5;
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+function requiredText$1(parent, name, path) {
+	const value = childText(parent, name);
+	if (value === void 0) throw xmlFailure(`hiányzik a(z) <${path}/${name}> elem.`);
+	return value;
+}
+function checkedDate(value, name, path) {
+	if (!DATE_PATTERN.test(value)) throw xmlFailure(`a(z) <${path}/${name}> nem ÉÉÉÉ-HH-NN formátumú dátum: ${value}.`);
+	return value;
+}
+function requiredDate(parent, name, path) {
+	return checkedDate(requiredText$1(parent, name, path), name, path);
+}
+function optionalDate(parent, name, path) {
+	const value = childText(parent, name);
+	return value === void 0 ? void 0 : checkedDate(value, name, path);
+}
+function typeCodeOf(header) {
+	if (childBoolean(header, "dijbekero") === true) return "D";
+	if (childBoolean(header, "elolegszamla") === true) return "ES";
+	if (childBoolean(header, "vegszamla") === true) return "VS";
+	if (childBoolean(header, "helyesbitoszamla") === true) return "HS";
+	if (childBoolean(header, "szallitolevel") === true) return "SL";
+	return "SZ";
+}
+function seriesOf(typeCode, prefix, eInvoice) {
+	if (typeCode === "D") return `D-${prefix}`;
+	if (typeCode === "SL") return `SZL-${prefix}`;
+	return eInvoice ? `E-${prefix}` : prefix;
+}
+function buyerOf(root) {
+	const buyer = findChild(root, "vevo");
+	return {
+		name: requiredText$1(buyer, "nev", "vevo"),
+		identifier: childText(buyer, "azonosito"),
+		country: childText(buyer, "orszag"),
+		zip: requiredText$1(buyer, "irsz", "vevo"),
+		city: requiredText$1(buyer, "telepules", "vevo"),
+		address: requiredText$1(buyer, "cim", "vevo"),
+		email: childText(buyer, "email"),
+		taxNumber: childText(buyer, "adoszam"),
+		groupTaxNumber: childText(buyer, "csoportazonosito"),
+		euTaxNumber: childText(buyer, "adoszamEU")
+	};
+}
+function sellerOf(state, root) {
+	const seller = findChild(root, "elado");
+	const defaults = state.config.seller;
+	return {
+		...defaults,
+		bankName: childText(seller, "bank") ?? defaults.bankName,
+		bankAccount: childText(seller, "bankszamlaszam") ?? defaults.bankAccount
+	};
+}
+function resolvePrefix$1(state, header) {
+	const prefix = childText(header, "szamlaszamElotag") ?? state.config.defaultInvoicePrefix;
+	const allowed = state.config.invoicePrefixes;
+	if (allowed !== void 0 && !allowed.has(prefix)) throw agentFailure(202);
+	return prefix;
+}
+function marginVatOf(root, header) {
+	const wholeInvoice = childBoolean(header, "arresAfa") === true;
+	const items = findChildren(findChild(root, "tetelek"), "tetel");
+	return (index) => wholeInvoice || childText(items[index], "arresAfaAlap") !== void 0;
+}
+function readInvoiceRequest(state, root) {
+	const settings = findChild(root, "beallitasok");
+	const header = findChild(root, "fejlec");
+	if (!header) throw xmlFailure("hiányzik a <fejlec> blokk.");
+	const currency = requiredText$1(header, "penznem", "fejlec");
+	const language = requiredText$1(header, "szamlaNyelve", "fejlec");
+	if (!LANGUAGES.has(language)) throw xmlFailure(`ismeretlen számlanyelv: ${language}.`);
+	const issueDate = requiredDate(header, "keltDatum", "fejlec");
+	const fulfillmentDate = requiredDate(header, "teljesitesDatum", "fejlec");
+	const dueDate = requiredDate(header, "fizetesiHataridoDatum", "fejlec");
+	const paymentMethod = requiredText$1(header, "fizmod", "fejlec");
+	const buyer = buyerOf(root);
+	const items = parseItems(root, "invoice");
+	const prefix = resolvePrefix$1(state, header);
+	assertInvoiceItems(items, currency, marginVatOf(root, header));
+	const typeCode = typeCodeOf(header);
+	const eInvoice = childBoolean(settings, "eszamla") === true;
+	const totals = totalsOf(items);
+	const foreign = !isHuf(currency);
+	return {
+		preview: childBoolean(header, "elonezetpdf") === true,
+		downloadPdf: childBoolean(settings, "szamlaLetoltes") === true,
+		fields: {
+			prefix,
+			series: seriesOf(typeCode, prefix, eInvoice),
+			typeCode,
+			eInvoice,
+			issueDate,
+			fulfillmentDate,
+			dueDate,
+			paymentMethod,
+			language,
+			currency,
+			exchangeBank: foreign ? childText(header, "arfolyamBank") : void 0,
+			exchangeRate: foreign ? childNumber(header, "arfolyam") : void 0,
+			comment: childText(header, "megjegyzes"),
+			orderNumber: childText(header, "rendelesSzam"),
+			externalId: childText(settings, "szamlaKulsoAzon"),
+			referencedInvoiceNumber: childText(header, "helyesbitettSzamlaszam") ?? childText(header, "elolegSzamlaszam"),
+			referencedProformaNumber: childText(header, "dijbekeroSzamlaszam"),
+			seller: sellerOf(state, root),
+			buyer,
+			items,
+			totals,
+			payments: childBoolean(header, "fizetve") === true ? [{
+				date: issueDate,
+				method: paymentMethod,
+				amount: totals.gross
+			}] : [],
+			reversed: false,
+			deleted: false
+		}
+	};
+}
+function activeInvoice(state, number) {
+	const invoice = state.invoices.get(number);
+	return invoice && !invoice.deleted ? invoice : void 0;
+}
+function paidAmount(invoice) {
+	return invoice.payments.reduce((sum, payment) => sum + payment.amount, 0);
+}
+function resultFields(invoice, pdf) {
+	return {
+		number: invoice.number,
+		netTotal: invoice.totals.net,
+		grossTotal: invoice.totals.gross,
+		outstanding: invoice.typeCode === "SS" ? void 0 : outstandingOf(invoice.totals.gross, paidAmount(invoice)),
+		paymentMethod: invoice.paymentMethod,
+		pdf: pdf ? fakePdf(invoice.number) : void 0
+	};
+}
+function invoiceResult(invoice, version, downloadPdf) {
+	return invoiceResultResponse(resultFields(invoice, downloadPdf), version);
+}
+function isSameInvoice(existing, fields) {
+	return existing.buyer.name === fields.buyer.name && existing.totals.gross === fields.totals.gross && existing.issueDate === fields.issueDate && existing.dueDate === fields.dueDate && existing.fulfillmentDate === fields.fulfillmentDate;
+}
+function findOrderDuplicate(state, fields) {
+	const { orderNumber, typeCode } = fields;
+	if (!state.config.uniqueInvoiceOrderNumbers || orderNumber === void 0 || typeCode === "HS") return;
+	return [...state.invoices.values()].findLast((invoice) => invoice.typeCode === typeCode && invoice.orderNumber === orderNumber && !invoice.reversed && !invoice.deleted);
+}
+function handleCreateInvoice(state, request) {
+	const version = responseVersion(request.root);
+	const { fields, preview, downloadPdf } = readInvoiceRequest(state, request.root);
+	if (preview) return invoiceResultResponse({
+		netTotal: fields.totals.net,
+		grossTotal: fields.totals.gross,
+		pdf: fakePdf("előnézet")
+	}, version);
+	const duplicate = findOrderDuplicate(state, fields);
+	if (duplicate) {
+		if (!(state.now().getTime() - duplicate.createdAt <= DUPLICATE_WINDOW_MS) || !isSameInvoice(duplicate, fields)) throw agentFailure(152, `Már létező rendelésszám: ${fields.orderNumber}. Az ismétlődés engedélyezhető a Beállítások oldalon.`);
+		return invoiceResult(duplicate, version, downloadPdf);
+	}
+	const invoice = {
+		...fields,
+		id: nextDocumentId(state),
+		number: nextDocumentNumber(state, fields.series),
+		createdAt: state.now().getTime()
+	};
+	state.invoices.set(invoice.number, invoice);
+	return invoiceResult(invoice, version, downloadPdf);
+}
+function reversalOf(state, original, root) {
+	const settings = findChild(root, "beallitasok");
+	const header = findChild(root, "fejlec");
+	const buyer = findChild(root, "vevo");
+	const issueDate = optionalDate(header, "keltDatum", "fejlec") ?? today(state);
+	return {
+		...original,
+		id: nextDocumentId(state),
+		number: nextDocumentNumber(state, original.series),
+		typeCode: "SS",
+		createdAt: state.now().getTime(),
+		eInvoice: original.eInvoice || childBoolean(settings, "eszamla") === true,
+		issueDate,
+		fulfillmentDate: optionalDate(header, "teljesitesDatum", "fejlec") ?? original.fulfillmentDate,
+		dueDate: issueDate,
+		comment: childText(header, "megjegyzes"),
+		externalId: childText(settings, "szamlaKulsoAzon"),
+		referencedInvoiceNumber: original.number,
+		referencedProformaNumber: void 0,
+		buyer: {
+			...original.buyer,
+			email: childText(buyer, "email") ?? original.buyer.email,
+			taxNumber: childText(buyer, "adoszam") ?? original.buyer.taxNumber
+		},
+		items: original.items.map(negateItem),
+		totals: negateTotals(original.totals),
+		payments: [],
+		reversed: false,
+		deleted: false
+	};
+}
+function handleReverseInvoice(state, request) {
+	const { root } = request;
+	const version = responseVersion(root);
+	const downloadPdf = childBoolean(findChild(root, "beallitasok"), "szamlaLetoltes") === true;
+	const number = requiredText$1(findChild(root, "fejlec"), "szamlaszam", "fejlec");
+	const original = activeInvoice(state, number);
+	if (!original) throw agentFailure(7, `Hiányzó adat: sztornózandó számla (ismeretlen számlaszám: ${number}).`);
+	if (original.typeCode === "D" || original.typeCode === "SL") return invoiceResult(original, version, downloadPdf);
+	if (original.typeCode === "SS") throw new FakeAgentFailure(void 0, `A(z) ${number} sztornó számla, nem sztornózható.`);
+	if (original.reversed) throw new FakeAgentFailure(void 0, `A(z) ${number} számlát már sztornózták.`);
+	const reversal = reversalOf(state, original, root);
+	state.invoices.set(original.number, {
+		...original,
+		reversed: true
+	});
+	state.invoices.set(reversal.number, reversal);
+	return invoiceResult(reversal, version, downloadPdf);
+}
+function paymentOf$1(element, index) {
+	const path = `kifizetes[${index + 1}]`;
+	const amount = childNumber(element, "osszeg");
+	if (amount === void 0) throw xmlFailure(`a(z) <${path}/osszeg> hiányzik vagy nem szám.`);
+	return {
+		date: requiredDate(element, "datum", path),
+		method: requiredText$1(element, "jogcim", path),
+		amount,
+		comment: childText(element, "leiras")
+	};
+}
+function handleRegisterPayment(state, request) {
+	const { root } = request;
+	const settings = findChild(root, "beallitasok");
+	const number = requiredText$1(settings, "szamlaszam", "beallitasok");
+	const additive = childBoolean(settings, "additiv");
+	if (additive === void 0) throw xmlFailure("hiányzik a(z) <beallitasok/additiv> elem.");
+	const elements = findChildren(root, "kifizetes");
+	if (elements.length > MAX_PAYMENTS) throw xmlFailure(`egy kérésben legfeljebb ${MAX_PAYMENTS} <kifizetes> elem lehet.`);
+	const entries = elements.map(paymentOf$1);
+	const invoice = activeInvoice(state, number);
+	if (!invoice) throw agentFailure(7, `Hiányzó adat: ismeretlen számlaszám (${number}).`);
+	const updated = {
+		...invoice,
+		payments: additive ? [...invoice.payments, ...entries] : entries
+	};
+	state.invoices.set(number, updated);
+	const fields = {
+		...resultFields(updated, false),
+		paymentMethod: void 0
+	};
+	if (responseVersion(root) === 2) return invoiceResultResponse(fields, 2);
+	return textResponse("xmlagentresponse=DONE\n", invoiceResultHeaders(fields));
+}
+function lookupInvoice(state, root) {
+	const number = childText(root, "szamlaszam");
+	if (number !== void 0) return activeInvoice(state, number);
+	const orderNumber = childText(root, "rendelesSzam");
+	const externalId = childText(root, "szamlaKulsoAzon");
+	if (orderNumber === void 0 && externalId === void 0) throw xmlFailure("add meg a számlaszámot, a rendelésszámot vagy a külső azonosítót.");
+	return [...state.invoices.values()].findLast((invoice) => !invoice.deleted && (orderNumber !== void 0 ? invoice.orderNumber === orderNumber : invoice.externalId === externalId));
+}
+function handleGetInvoicePdf(state, request) {
+	const invoice = lookupInvoice(state, request.root);
+	if (!invoice) throw agentFailure(7, "Hiányzó adat: számla pdf (ismeretlen számlaszám, rendelésszám vagy külső azonosító).");
+	return invoiceResult(invoice, responseVersion(request.root), true);
+}
+function handleGetInvoiceXml(state, request) {
+	const invoice = lookupInvoice(state, request.root);
+	if (!invoice) throw agentFailure(7, "Hiányzó adat: számla xml (ismeretlen számlaszám, rendelésszám vagy külső azonosító).");
+	const includePdf = childBoolean(request.root, "pdf") === true;
+	return xmlResponse(renderInvoiceXml(invoice, state.config.testAccount, includePdf));
+}
+function handleDeleteProforma(state, request) {
+	const header = findChild(request.root, "fejlec");
+	const number = childText(header, "szamlaszam");
+	const orderNumber = childText(header, "rendelesszam");
+	if (number === void 0 && orderNumber === void 0) throw xmlFailure("add meg a díjbekérő számát vagy a rendelésszámot.");
+	const targets = [...state.invoices.values()].filter((invoice) => invoice.typeCode === "D" && !invoice.deleted && (number !== void 0 ? invoice.number === number : invoice.orderNumber === orderNumber));
+	if (targets.length === 0) throw agentFailure(335);
+	for (const target of targets) state.invoices.set(target.number, {
+		...target,
+		deleted: true
+	});
+	return xmlResponse(xmlDocument("xmlszamladbkdelvalasz", [el("sikeres", true)]));
+}
+//#endregion
+//#region src/testing/fake-agent-receipts.ts
+const PREFIX_PATTERN = /^[A-Z0-9]+$/;
+const MONEY_DECIMALS = 2;
+function requiredText(parent, name, path) {
+	const value = childText(parent, name);
+	if (value === void 0) throw xmlFailure(`hiányzik a(z) <${path}/${name}> elem.`);
+	return value;
+}
+function assertUnusedCallId(state, callId) {
+	if (callId === void 0) return;
+	if ([...state.receipts.values()].some((receipt) => receipt.callId === callId)) throw agentFailure(338, `A hívásazonosító már létezik: ${callId}.`);
+}
+function isInvoicePrefix(state, prefix) {
+	if (state.config.invoicePrefixes?.has(prefix)) return true;
+	return [...state.invoices.values()].some((invoice) => invoice.prefix === prefix);
+}
+function resolvePrefix(state, header) {
+	const prefix = requiredText(header, "elotag", "fejlec");
+	if (!PREFIX_PATTERN.test(prefix)) throw agentFailure(337);
+	if (isInvoicePrefix(state, prefix)) throw agentFailure(336);
+	const enabled = state.config.receiptPrefixes;
+	if (enabled !== void 0 && !enabled.has(prefix)) throw agentFailure(524);
+	return prefix;
+}
+function paymentOf(element, index) {
+	const path = `kifizetesek/kifizetes[${index + 1}]`;
+	const amount = childNumber(element, "osszeg");
+	if (amount === void 0) throw xmlFailure(`a(z) <${path}/osszeg> hiányzik vagy nem szám.`);
+	return {
+		method: requiredText(element, "fizetoeszkoz", path),
+		amount,
+		description: childText(element, "leiras")
+	};
+}
+function assertPaymentsMatch(payments, gross) {
+	if (payments.length === 0) return;
+	const paid = roundMoney(payments.reduce((sum, payment) => sum + payment.amount, 0), MONEY_DECIMALS);
+	if (paid !== roundMoney(gross, MONEY_DECIMALS)) throw agentFailure(340, `A kifizetett összeg (${paid}) eltér a bruttó végösszegtől (${gross}).`);
+}
+function assertUniqueOrderNumber(state, orderNumber) {
+	if (!state.config.uniqueReceiptOrderNumbers || orderNumber === void 0) return;
+	if ([...state.receipts.values()].some((receipt) => receipt.type === "NY" && receipt.orderNumber === orderNumber && !receipt.reversed)) throw agentFailure(152, `Már létező rendelésszám: ${orderNumber}. Az ismétlődés engedélyezhető a Beállítások oldalon.`);
+}
+function exchangeOf(header, currency) {
+	if (isHuf(currency)) return {
+		exchangeBank: void 0,
+		exchangeRate: void 0
+	};
+	const exchangeRate = childNumber(header, "devizaarf");
+	const exchangeBank = childText(header, "devizabank");
+	if (exchangeRate === void 0 || exchangeRate <= 0 || exchangeBank === void 0) throw xmlFailure(`devizás (${currency}) nyugtánál az árfolyam (devizaarf) és a bank (devizabank) megadása kötelező.`);
+	return {
+		exchangeBank,
+		exchangeRate
+	};
+}
+function itemNode(item) {
+	return el("tetel", [
+		el("megnevezes", item.name),
+		optionalEl("azonosito", item.identifier),
+		el("nettoEgysegar", item.netUnitPrice),
+		el("mennyiseg", item.quantity),
+		el("mennyisegiEgyseg", item.unit),
+		el("netto", item.netAmount),
+		optionalEl("afatipus", item.vatCode),
+		el("afakulcs", item.vatRate),
+		el("afa", item.vatAmount),
+		el("brutto", item.grossAmount),
+		item.ledger && optionalEl("fokonyv", [optionalEl("arbevetel", item.ledger.revenue), optionalEl("afa", item.ledger.vat)])
+	]);
+}
+function paymentNode(payment) {
+	return el("kifizetes", [
+		el("fizetoeszkoz", payment.method),
+		el("osszeg", payment.amount),
+		optionalEl("leiras", payment.description)
+	]);
+}
+function receiptNode(receipt, testAccount) {
+	return el("nyugta", [
+		el("alap", [
+			el("id", receipt.id),
+			optionalEl("hivasAzonosito", receipt.callId),
+			el("nyugtaszam", receipt.number),
+			el("tipus", receipt.type),
+			el("stornozott", receipt.reversed),
+			optionalEl("stornozottNyugtaszam", receipt.reversedNumber),
+			el("kelt", receipt.issueDate),
+			el("fizmod", receipt.paymentMethod),
+			el("penznem", receipt.currency),
+			optionalEl("devizabank", receipt.exchangeBank),
+			optionalEl("devizaarf", receipt.exchangeRate),
+			optionalEl("megjegyzes", receipt.comment),
+			optionalEl("fokonyvVevo", receipt.customerLedgerId),
+			el("teszt", testAccount),
+			optionalEl("rendelesSzam", receipt.orderNumber)
+		]),
+		el("tetelek", receipt.items.map(itemNode)),
+		receipt.payments.length > 0 && el("kifizetesek", receipt.payments.map(paymentNode)),
+		el("osszegek", [...vatGroupsOf(receipt.items).map(vatGroupNode), totalNode(receipt.totals)])
+	]);
+}
+function receiptResponse(state, receipt, includePdf) {
+	return xmlResponse(xmlDocument("xmlnyugtavalasz", [
+		el("sikeres", true),
+		includePdf && el("nyugtaPdf", bytesToBase64(fakePdf(receipt.number))),
+		receiptNode(receipt, state.config.testAccount)
+	]));
+}
+function downloadPdfOf(root) {
+	return childBoolean(findChild(root, "beallitasok"), "pdfLetoltes") === true;
+}
+function handleCreateReceipt(state, request) {
+	const { root } = request;
+	const header = findChild(root, "fejlec");
+	if (!header) throw xmlFailure("hiányzik a <fejlec> blokk.");
+	const callId = childText(header, "hivasAzonosito");
+	assertUnusedCallId(state, callId);
+	const prefix = resolvePrefix(state, header);
+	const paymentMethod = requiredText(header, "fizmod", "fejlec");
+	const currency = childText(header, "penznem") ?? "HUF";
+	const exchange = exchangeOf(header, currency);
+	const items = parseItems(root, "receipt");
+	assertReceiptItems(items, currency);
+	const totals = totalsOf(items);
+	const payments = findChildren(findChild(root, "kifizetesek"), "kifizetes").map(paymentOf);
+	assertPaymentsMatch(payments, totals.gross);
+	const orderNumber = childText(header, "rendelesSzam");
+	assertUniqueOrderNumber(state, orderNumber);
+	const receipt = {
+		id: nextDocumentId(state),
+		number: nextDocumentNumber(state, prefix),
+		prefix,
+		callId,
+		type: "NY",
+		reversed: false,
+		issueDate: today(state),
+		paymentMethod,
+		currency,
+		...exchange,
+		comment: childText(header, "megjegyzes"),
+		customerLedgerId: childText(header, "fokonyvVevo"),
+		orderNumber,
+		items,
+		payments,
+		totals,
+		sentTo: []
+	};
+	state.receipts.set(receipt.number, receipt);
+	return receiptResponse(state, receipt, downloadPdfOf(root));
+}
+function handleReverseReceipt(state, request) {
+	const { root } = request;
+	const header = findChild(root, "fejlec");
+	const number = requiredText(header, "nyugtaszam", "fejlec");
+	const callId = childText(header, "hivasAzonosito");
+	assertUnusedCallId(state, callId);
+	const original = state.receipts.get(number);
+	if (!original) throw agentFailure(339, "Hiányzó adat: sztornózandó nyugta (nincs ilyen nyugtaszám)");
+	if (original.type === "SN") throw new FakeAgentFailure(void 0, "Hiányzó adat: sztornózandó nyugta (ez a nyugta egy sztornónyugta)");
+	if (original.reversed) throw new FakeAgentFailure(void 0, `Hiányzó adat: sztornózandó nyugta (ezt a nyugtát már sztornózták: ${number})`);
+	const reversal = {
+		...original,
+		id: nextDocumentId(state),
+		number: nextDocumentNumber(state, original.prefix),
+		callId,
+		type: "SN",
+		reversed: false,
+		reversedNumber: original.number,
+		issueDate: today(state),
+		items: original.items.map(negateItem),
+		payments: original.payments.map((payment) => ({
+			...payment,
+			amount: -payment.amount
+		})),
+		totals: negateTotals(original.totals),
+		sentTo: []
+	};
+	state.receipts.set(original.number, {
+		...original,
+		reversed: true
+	});
+	state.receipts.set(reversal.number, reversal);
+	return receiptResponse(state, reversal, downloadPdfOf(root));
+}
+function handleGetReceipt(state, request) {
+	const { root } = request;
+	const header = findChild(root, "fejlec");
+	const number = childText(header, "nyugtaszam");
+	const orderNumber = childText(header, "rendelesSzam");
+	if (number === void 0 && orderNumber === void 0) throw xmlFailure("add meg a nyugtaszámot (nyugtaszam) vagy a rendelésszámot (rendelesSzam).");
+	const receipt = number !== void 0 ? state.receipts.get(number) : [...state.receipts.values()].findLast((candidate) => candidate.orderNumber === orderNumber);
+	if (!receipt) throw agentFailure(339);
+	return receiptResponse(state, receipt, downloadPdfOf(root));
+}
+function handleSendReceipt(state, request) {
+	const { root } = request;
+	const number = requiredText(findChild(root, "fejlec"), "nyugtaszam", "fejlec");
+	const email = findChild(root, "emailKuldes");
+	const recipients = childText(email, "email");
+	if (recipients === void 0) throw agentFailure(7, "Hiányzó adat: email elem.");
+	if (childText(email, "emailTargy") === void 0) throw agentFailure(7, "Hiányzó adat: emailtargy elem.");
+	const receipt = state.receipts.get(number);
+	if (!receipt) throw agentFailure(339);
+	const addresses = recipients.split(/[,;]/).map((address) => address.trim()).filter((address) => address !== "");
+	state.receipts.set(number, {
+		...receipt,
+		sentTo: [...receipt.sentTo, addresses]
+	});
+	return xmlResponse(xmlDocument("xmlnyugtasendvalasz", [el("sikeres", true)]));
+}
+//#endregion
+//#region src/testing/fake-agent.ts
+const HANDLERS = {
+	createInvoice: handleCreateInvoice,
+	reverseInvoice: handleReverseInvoice,
+	registerPayment: handleRegisterPayment,
+	getInvoicePdf: handleGetInvoicePdf,
+	getInvoiceXml: handleGetInvoiceXml,
+	deleteProforma: handleDeleteProforma,
+	createReceipt: handleCreateReceipt,
+	reverseReceipt: handleReverseReceipt,
+	getReceipt: handleGetReceipt,
+	sendReceipt: handleSendReceipt,
+	queryTaxpayer: handleQueryTaxpayer,
+	connectPrincipal: handleConnectPrincipal
+};
+const NAMED_FAULTS = {
+	ghostSuccess: {
+		stage: "after",
+		effect: "timeout"
+	},
+	timeout: {
+		stage: "before",
+		effect: "timeout"
+	},
+	networkError: {
+		stage: "before",
+		effect: "network"
+	},
+	serverError: {
+		stage: "before",
+		effect: "server-error"
+	},
+	maintenance: {
+		stage: "before",
+		effect: "code",
+		code: 1
+	},
+	partialSuccess: {
+		stage: "after",
+		effect: "code",
+		code: 56
+	},
+	testAccountLimit: {
+		stage: "before",
+		effect: "code",
+		code: 167
+	},
+	duplicateCallId: {
+		stage: "before",
+		effect: "code",
+		code: 338
+	},
+	duplicateOrderNumber: {
+		stage: "before",
+		effect: "code",
+		code: 152
+	}
+};
+const DEFAULT_SELLER = {
+	name: "Kassza Teszt Kft.",
+	taxNumber: "12345676-2-42",
+	zip: "1111",
+	city: "Budapest",
+	address: "Teszt utca 1."
+};
+const DEFAULT_INVOICE_PREFIX = "KASSZA";
+const KNOWN_ACTIONS = new Set(Object.keys(AGENT_ACTIONS));
+function behaviorOf(fault) {
+	if (typeof fault === "string") {
+		const behavior = NAMED_FAULTS[fault];
+		if (!behavior) throw new TypeError(`Ismeretlen hamis Agent hiba: ${String(fault)}`);
+		return behavior;
+	}
+	if (!Number.isInteger(fault.code) || fault.code < 1) throw new TypeError(`A hibakód pozitív egész szám legyen, kapott: ${String(fault.code)}`);
+	return {
+		stage: fault.afterSuccess === true ? "after" : "before",
+		effect: "code",
+		code: fault.code,
+		message: fault.message
+	};
+}
+function pendingFault(fault, options) {
+	const times = options.times ?? 1;
+	if (!Number.isInteger(times) || times < 1) throw new TypeError(`A times értéke legalább 1 egész szám legyen, kapott: ${String(times)}`);
+	if (options.action !== void 0 && !KNOWN_ACTIONS.has(options.action)) throw new TypeError(`Ismeretlen Agent művelet: ${String(options.action)}`);
+	return {
+		behavior: behaviorOf(fault),
+		action: options.action,
+		remaining: times
+	};
+}
+function duplicateFlags(value) {
+	if (typeof value === "boolean") return {
+		invoices: value,
+		receipts: value
+	};
+	return {
+		invoices: value?.invoices === true,
+		receipts: value?.receipts === true
+	};
+}
+function normalizedTaxpayers(taxpayers) {
+	return Object.fromEntries(Object.entries(taxpayers ?? {}).map(([taxNumber, taxpayer]) => [taxpayerKey(taxNumber), taxpayer]));
+}
+function seededPrincipals(options) {
+	return new Map(Object.entries(options.principals ?? {}).map(([taxNumber, state]) => [taxpayerKey(taxNumber), {
+		state,
+		joinRequests: 0
+	}]));
+}
+function createState(options) {
+	const duplicates = duplicateFlags(options.rejectDuplicateOrderNumbers);
+	return {
+		now: options.now ?? (() => /* @__PURE__ */ new Date()),
+		config: {
+			seller: {
+				...DEFAULT_SELLER,
+				...options.seller
+			},
+			testAccount: options.testAccount ?? true,
+			defaultInvoicePrefix: options.defaultInvoicePrefix ?? options.invoicePrefixes?.[0] ?? DEFAULT_INVOICE_PREFIX,
+			invoicePrefixes: options.invoicePrefixes && new Set(options.invoicePrefixes),
+			receiptPrefixes: options.receiptPrefixes && new Set(options.receiptPrefixes),
+			uniqueInvoiceOrderNumbers: duplicates.invoices,
+			uniqueReceiptOrderNumbers: duplicates.receipts,
+			strictAuth: options.agentKeys !== void 0 || options.users !== void 0,
+			agentKeys: new Set(options.agentKeys ?? []),
+			taxpayers: normalizedTaxpayers(options.taxpayers)
+		},
+		invoices: /* @__PURE__ */ new Map(),
+		receipts: /* @__PURE__ */ new Map(),
+		counters: /* @__PURE__ */ new Map(),
+		principals: seededPrincipals(options),
+		delegates: /* @__PURE__ */ new Map(),
+		users: new Map(Object.entries(options.users ?? {}))
+	};
+}
+function timeoutError() {
+	return new DOMException("A hamis Agent nem küldött választ (időtúllépés).", "TimeoutError");
+}
+function orderNumberOf(root) {
+	return childText(findChild(root, "fejlec"), "rendelesSzam");
+}
+function faultFailure(behavior, root) {
+	const code = behavior.code ?? 1;
+	if (behavior.message !== void 0) return new FakeAgentFailure(code, behavior.message);
+	if (code === 152) return agentFailure(152, `Már létező rendelésszám: ${orderNumberOf(root) ?? "XXX"}. Az ismétlődés engedélyezhető a Beállítások oldalon.`);
+	return agentFailure(code);
+}
+function respondBefore(behavior, request) {
+	if (behavior.effect === "timeout") throw timeoutError();
+	if (behavior.effect === "network") throw new TypeError("fetch failed");
+	if (behavior.effect === "server-error") return serverErrorResponse();
+	return errorResponse(errorStyleFor(request.action, request.root), faultFailure(behavior, request.root));
+}
+function createFakeAgentFetch(options = {}) {
+	let state = createState(options);
+	const requests = [];
+	const faults = [];
+	const scheduleInitialFaults = () => {
+		for (const scheduled of options.faults ?? []) faults.push(pendingFault(scheduled.fault, scheduled));
+	};
+	scheduleInitialFaults();
+	const takeFault = (action) => {
+		const index = faults.findIndex((fault) => fault.action === void 0 || fault.action === action);
+		const fault = faults[index];
+		if (!fault) return void 0;
+		fault.remaining -= 1;
+		if (fault.remaining === 0) faults.splice(index, 1);
+		return fault.behavior;
+	};
+	const perform = (request) => {
+		try {
+			authenticate(state, credentialsOf(request.root));
+			return {
+				response: HANDLERS[request.action](state, request),
+				ok: true
+			};
+		} catch (error) {
+			if (!(error instanceof FakeAgentFailure)) throw error;
+			return {
+				response: errorResponse(errorStyleFor(request.action, request.root), error),
+				ok: false
+			};
+		}
+	};
+	const handle = (action, xml, attachments) => {
+		let request;
+		try {
+			request = parseFakeAgentRequest(action, xml, attachments);
+		} catch (error) {
+			if (!(error instanceof FakeAgentFailure)) throw error;
+			return errorResponse(errorStyleFor(action, void 0), error);
+		}
+		const fault = takeFault(action);
+		if (fault?.stage === "before") return respondBefore(fault, request);
+		const { response, ok } = perform(request);
+		if (fault?.effect === "timeout") throw timeoutError();
+		if (fault && ok) return errorResponse(errorStyleFor(action, request.root), faultFailure(fault, request.root));
+		return response;
+	};
+	const fakeFetch = async (input, init) => {
+		init?.signal?.throwIfAborted();
+		const record = await readFakeAgentForm(input, init);
+		requests.push(record);
+		if (record.action === void 0 || record.xml === void 0) return toFetchResponse(errorResponse("text", agentFailure(53)));
+		return toFetchResponse(handle(record.action, record.xml, record.attachments));
+	};
+	return {
+		fetch: fakeFetch,
+		requests,
+		get invoices() {
+			return state.invoices;
+		},
+		get receipts() {
+			return state.receipts;
+		},
+		fail(fault, faultOptions = {}) {
+			faults.push(pendingFault(fault, faultOptions));
+		},
+		acceptDelegation(taxNumber) {
+			acceptDelegation(state, taxNumber);
+		},
+		reset() {
+			state = createState(options);
+			requests.length = 0;
+			faults.length = 0;
+			scheduleInitialFaults();
+		}
+	};
+}
+//#endregion
 //#region src/testing/index.ts
 const MOCK_PDF = new TextEncoder().encode("%PDF-1.4\n1 0 obj << /Type /Catalog >> endobj\ntrailer << /Root 1 0 R >>\n%%EOF\n");
 function notFound(code, message) {
@@ -503,4 +1974,4 @@ function createMockKassza(options = {}) {
 	};
 }
 //#endregion
-export { MOCK_PDF, createMockKassza };
+export { CONNECT_PRINCIPAL_MESSAGES, MOCK_PDF, createFakeAgentFetch, createMockKassza };