kassza 0.12.0 → 0.14.0

package/dist/nav/index.js

@@ -0,0 +1,1012 @@
+import { a as optionalEl, d as findChildren, f as parseXml, l as childText, n as buildXmlDocument, o as XmlParseError, r as el, t as XSI_NAMESPACE, u as findChild } from "../serialize-B2eFh3D-.js";
+import { a as todayInBudapest, n as toAgentDate } from "../dates-CXyj7Azy.js";
+import { n as decimalPlaces, r as roundMoney } from "../rounding-BLyHjjI5.js";
+import { n as digestHex, t as bytesToHex } from "../crypto-usDg8L2K.js";
+import { o as NAV_VAT_CATEGORIES, t as compareReceiptNumbers } from "../nav-BcCerwWS.js";
+//#region src/nav/errors.ts
+const NAV_RECEIPT_ERROR_CODES = {
+	EPGP0002: {
+		name: "NEM_LETEZO_SZOFTVER",
+		message: "Nem létező nyugtakiállító szoftver megnevezés.",
+		category: "business",
+		hint: "Rögzítsd a szoftver nevét a registerSoftware hívással (/issuing-software/create), mielőtt adatot küldesz."
+	},
+	EPGP0009: {
+		name: "NYUGTAADAT_MODOSITAS_NEM_ENGEDELYEZETT",
+		message: "A nyugta-adatszolgáltatás módosítása nem engedélyezett.",
+		category: "business",
+		hint: "Érvénytelenített vagy már módosított adatszolgáltatás nem módosítható; a legutóbbi RECORDED rekordot módosítsd."
+	},
+	EPGP0010: {
+		name: "HIBAS_NYUGTAADAT_MENTES",
+		message: "Hiba a nyugta-adatszolgáltatás mentése során.",
+		category: "technical"
+	},
+	EPGP0011: {
+		name: "NEM_LETEZO_NYUGTAADAT",
+		message: "A megadott nyugta-adatszolgáltatás nem létezik.",
+		category: "business"
+	},
+	EPGP0013: {
+		name: "ISMERETLEN_DEVIZA_KOD",
+		message: "Ismeretlen pénznemkód.",
+		category: "validation",
+		hint: "Csak a currencies() (/currency/list) által visszaadott pénznem küldhető."
+	},
+	EPGP0017: {
+		name: "HIBAS_AFA_KATEGORIA",
+		message: "Nem található a megadott ÁFA kategória.",
+		category: "validation",
+		hint: "Csak a vatCategories() (/vat-category/list) által a tárgynapra érvényes kategória küldhető."
+	},
+	EPGP0020: {
+		name: "DUPLIKALT_AFA_KATEGORIA",
+		message: "Egy ÁFA kategória többször szerepel az adatszolgáltatásban.",
+		category: "validation"
+	},
+	EPGP0046: {
+		name: "ELTERO_TOKEN_HIBA",
+		message: "A kérés törzsszáma eltér a tokenben szereplő törzsszámtól.",
+		category: "auth"
+	},
+	EPGP0051: {
+		name: "LETEZO_HELYESBITO_ADATSZOLGALTATAS",
+		message: "Erre az adatszolgáltatásra már létezik helyesbítő adatszolgáltatás.",
+		category: "business",
+		hint: "Egy rekord csak egyszer módosítható; a módosítással létrejött új rekordot módosítsd tovább."
+	},
+	EPGP9000: {
+		name: "INTERNAL_ERROR",
+		message: "Belső, váratlan NAV hiba.",
+		category: "technical"
+	},
+	EPGP9001: {
+		name: "REQUEST_VALIDACIO_SIKERTELEN",
+		message: "A kérés nem felel meg a NAV validációs szabályainak.",
+		category: "validation"
+	}
+};
+const RETRYABLE_CATEGORIES = /* @__PURE__ */ new Set([
+	"network",
+	"timeout",
+	"technical"
+]);
+var NavReceiptError = class extends Error {
+	name = "NavReceiptError";
+	category;
+	code;
+	operation;
+	httpStatus;
+	fieldErrors;
+	hint;
+	rawResponse;
+	details;
+	constructor(message, options) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.category = options.category;
+		this.code = options.code;
+		this.operation = options.operation;
+		this.httpStatus = options.httpStatus;
+		this.fieldErrors = options.fieldErrors ?? [];
+		this.hint = options.hint;
+		this.rawResponse = options.rawResponse;
+		this.details = options.details;
+	}
+	get retryable() {
+		return RETRYABLE_CATEGORIES.has(this.category);
+	}
+};
+function isNavReceiptError(error) {
+	return error instanceof NavReceiptError;
+}
+//#endregion
+//#region src/nav/parse.ts
+const RAW_PREVIEW_LENGTH = 2e3;
+const UNAUTHORIZED$1 = 401;
+const FORBIDDEN = 403;
+const SERVER_ERROR = 500;
+const ERROR_ROOT_CATEGORIES = /* @__PURE__ */ new Map([
+	["TechnicalErrorResponse", "technical"],
+	["BusinessErrorResponse", "business"],
+	["InvalidRequestResponse", "validation"]
+]);
+function preview(body) {
+	const trimmed = body.trim();
+	return trimmed === "" ? void 0 : trimmed.slice(0, RAW_PREVIEW_LENGTH);
+}
+function statusCategory(status) {
+	if (status === UNAUTHORIZED$1 || status === FORBIDDEN) return "auth";
+	if (status >= SERVER_ERROR) return "technical";
+	return "unexpected_response";
+}
+function unexpected(operation, status, body, detail, cause) {
+	const category = status >= 200 && status < 300 ? "unexpected_response" : statusCategory(status);
+	return new NavReceiptError(`Váratlan NAV válasz (${operation}, HTTP ${status}): ${detail}`, {
+		category,
+		operation,
+		httpStatus: status,
+		rawResponse: preview(body),
+		cause
+	});
+}
+function fieldErrors(root) {
+	return findChildren(root, "error").map((entry) => ({
+		field: childText(entry, "field"),
+		error: childText(entry, "error")
+	}));
+}
+function errorFromRoot(operation, status, body, root) {
+	const code = childText(root, "errorCode");
+	const info = code === void 0 ? void 0 : NAV_RECEIPT_ERROR_CODES[code];
+	const message = childText(root, "message") ?? info?.message ?? "ismeretlen hiba";
+	const fields = fieldErrors(root);
+	const details = fields.map((entry) => [entry.field, entry.error].filter(Boolean).join(": ")).filter(Boolean);
+	const category = (status === UNAUTHORIZED$1 || status === FORBIDDEN ? "auth" : void 0) ?? info?.category ?? ERROR_ROOT_CATEGORIES.get(root.name) ?? statusCategory(status);
+	const suffix = details.length > 0 ? ` (${details.join("; ")})` : "";
+	return new NavReceiptError(`NAV hiba${code ? ` [${code}]` : ""}: ${message}${suffix}`, {
+		category,
+		code,
+		operation,
+		httpStatus: status,
+		fieldErrors: fields,
+		hint: info?.hint,
+		rawResponse: preview(body)
+	});
+}
+function parseNavResponse(operation, expectedRoot, status, body) {
+	if (body.trim() === "") throw unexpected(operation, status, body, "üres válasz.");
+	let root;
+	try {
+		root = parseXml(body);
+	} catch (error) {
+		if (!(error instanceof XmlParseError)) throw error;
+		throw unexpected(operation, status, body, "a válasz nem XML.", error);
+	}
+	if (ERROR_ROOT_CATEGORIES.has(root.name) || childText(root, "resultCode") === "ERROR") throw errorFromRoot(operation, status, body, root);
+	if (status < 200 || status >= 300) throw unexpected(operation, status, body, `a válasz gyökéreleme ${root.name}.`);
+	if (root.name !== expectedRoot) throw unexpected(operation, status, body, `${expectedRoot} helyett ${root.name} érkezett.`);
+	return root;
+}
+function requiredText(element, name, operation) {
+	const value = childText(element, name);
+	if (value === void 0) throw new NavReceiptError(`A NAV válaszából (${operation}) hiányzik a(z) ${name} mező.`, {
+		category: "unexpected_response",
+		operation
+	});
+	return value;
+}
+function requiredNumber(element, name, operation) {
+	const value = Number(requiredText(element, name, operation));
+	if (!Number.isFinite(value)) throw new NavReceiptError(`A NAV válaszában (${operation}) a(z) ${name} nem szám.`, {
+		category: "unexpected_response",
+		operation
+	});
+	return value;
+}
+function status(element, operation) {
+	const value = requiredText(element, "status", operation);
+	if (value !== "RECORDED" && value !== "INVALIDATED") throw new NavReceiptError(`Ismeretlen adatszolgáltatás-státusz: ${value}.`, {
+		category: "unexpected_response",
+		operation
+	});
+	return value;
+}
+function softwareName(element, operation) {
+	return requiredText(findChild(element, "issuingSoftware"), "name", operation);
+}
+function parseAuthTokenResponse(root) {
+	const token = childText(root, "token");
+	const validTo = childText(root, "validTo");
+	if (!token || !validTo) throw new NavReceiptError("A NAV nem adott hozzáférési tokent.", {
+		category: "auth",
+		operation: "authToken"
+	});
+	return {
+		token,
+		validTo
+	};
+}
+function parseIdResponse(root, operation) {
+	return requiredText(root, "id", operation);
+}
+function listItem(element) {
+	const operation = "listReceipts";
+	return {
+		id: requiredText(element, "id", operation),
+		applicableDate: requiredText(element, "applicableDate", operation),
+		serialNumber: requiredText(element, "serialNumber", operation),
+		numberOfSaleDocument: requiredNumber(element, "numberOfSaleDocument", operation),
+		numberOfModifyingDocument: requiredNumber(element, "numberOfModifyingDocument", operation),
+		totalAmount: requiredNumber(element, "totalAmount", operation),
+		totalAmountInForint: requiredNumber(element, "totalAmountInForint", operation),
+		status: status(element, operation),
+		softwareName: softwareName(element, operation)
+	};
+}
+function parseReceiptListResponse(root) {
+	const operation = "listReceipts";
+	const paging = findChild(root, "paging");
+	return {
+		items: findChildren(findChild(root, "result"), "receipt").map(listItem),
+		page: requiredNumber(paging, "page", operation),
+		pageSize: requiredNumber(paging, "pageSize", operation),
+		totalRowCount: requiredNumber(paging, "totalRowCount", operation)
+	};
+}
+function vatRows(root, operation) {
+	return findChildren(findChild(root, "vatCategoryItems"), "vatCategory").map((row) => ({
+		vat: requiredText(row, "vat", operation),
+		saleDocument: requiredNumber(row, "saleDocument", operation),
+		modifyingDocument: requiredNumber(row, "modifyingDocument", operation)
+	}));
+}
+function parseReceiptDetailResponse(root) {
+	const operation = "receiptDetail";
+	const rate = childText(root, "exchangeRate");
+	return {
+		id: requiredText(root, "id", operation),
+		softwareName: softwareName(root, operation),
+		applicableDate: requiredText(root, "applicableDate", operation),
+		status: status(root, operation),
+		serialNumber: requiredText(root, "serialNumber", operation),
+		currency: requiredText(root, "currency", operation),
+		exchangeRate: rate === void 0 ? null : Number(rate),
+		vatCategories: vatRows(root, operation),
+		total: requiredNumber(root, "total", operation),
+		totalAmountInForint: requiredNumber(root, "totalAmountInForint", operation),
+		numberOfSaleDocument: requiredNumber(root, "numberOfSaleDocument", operation),
+		numberOfModifyingDocument: requiredNumber(root, "numberOfModifyingDocument", operation)
+	};
+}
+function parseIssuingSoftwareListResponse(root) {
+	return findChildren(findChild(root, "issuingSoftwareList"), "software").map((software) => requiredText(software, "name", "listIssuingSoftware"));
+}
+function parseVatCategoryResponse(root) {
+	return findChildren(findChild(root, "categories"), "category").map((category) => ({
+		name: requiredText(category, "name", "vatCategories"),
+		validFrom: requiredText(category, "validFrom", "vatCategories"),
+		validTo: childText(category, "validTo")
+	}));
+}
+function parseCurrencyResponse(root) {
+	return findChildren(findChild(root, "currencies"), "currency").map((currency) => ({
+		code: requiredText(currency, "code", "currencies"),
+		name: requiredText(currency, "name", "currencies")
+	}));
+}
+//#endregion
+//#region src/nav/sha3.ts
+const RATE_BYTES = 72;
+const OUTPUT_BYTES = 64;
+const LANE_BYTES = 8;
+const LANES = 25;
+const ROUNDS = 24;
+const DOMAIN_SUFFIX = 6;
+const FINAL_BIT = 128;
+const MASK_64 = (1n << 64n) - 1n;
+const ROUND_CONSTANTS = [
+	1n,
+	32898n,
+	9223372036854808714n,
+	9223372039002292224n,
+	32907n,
+	2147483649n,
+	9223372039002292353n,
+	9223372036854808585n,
+	138n,
+	136n,
+	2147516425n,
+	2147483658n,
+	2147516555n,
+	9223372036854775947n,
+	9223372036854808713n,
+	9223372036854808579n,
+	9223372036854808578n,
+	9223372036854775936n,
+	32778n,
+	9223372039002259466n,
+	9223372039002292353n,
+	9223372036854808704n,
+	2147483649n,
+	9223372039002292232n
+];
+const ROTATIONS = [
+	0,
+	1,
+	62,
+	28,
+	27,
+	36,
+	44,
+	6,
+	55,
+	20,
+	3,
+	10,
+	43,
+	25,
+	39,
+	41,
+	45,
+	15,
+	21,
+	8,
+	18,
+	2,
+	61,
+	56,
+	14
+];
+function lane(lanes, index) {
+	return lanes[index] ?? 0n;
+}
+function rotateLeft(value, shift) {
+	if (shift === 0) return value;
+	const amount = BigInt(shift);
+	return (value << amount | value >> 64n - amount) & MASK_64;
+}
+function keccakF1600(state) {
+	const columns = new Array(5).fill(0n);
+	const rotated = new Array(LANES).fill(0n);
+	for (let round = 0; round < ROUNDS; round++) {
+		for (let x = 0; x < 5; x++) columns[x] = lane(state, x) ^ lane(state, x + 5) ^ lane(state, x + 10) ^ lane(state, x + 15) ^ lane(state, x + 20);
+		for (let x = 0; x < 5; x++) {
+			const delta = lane(columns, (x + 4) % 5) ^ rotateLeft(lane(columns, (x + 1) % 5), 1);
+			for (let y = 0; y < LANES; y += 5) state[x + y] = lane(state, x + y) ^ delta;
+		}
+		for (let x = 0; x < 5; x++) for (let y = 0; y < 5; y++) {
+			const source = x + 5 * y;
+			rotated[y + 5 * ((2 * x + 3 * y) % 5)] = rotateLeft(lane(state, source), ROTATIONS[source] ?? 0);
+		}
+		for (let y = 0; y < LANES; y += 5) for (let x = 0; x < 5; x++) {
+			const current = lane(rotated, x + y);
+			const next = lane(rotated, (x + 1) % 5 + y);
+			const afterNext = lane(rotated, (x + 2) % 5 + y);
+			state[x + y] = (current ^ ~next & afterNext) & MASK_64;
+		}
+		state[0] = lane(state, 0) ^ (ROUND_CONSTANTS[round] ?? 0n);
+	}
+}
+function pad(data) {
+	const blocks = Math.floor(data.length / RATE_BYTES) + 1;
+	const padded = new Uint8Array(blocks * RATE_BYTES);
+	padded.set(data);
+	padded[data.length] = (padded[data.length] ?? 0) ^ DOMAIN_SUFFIX;
+	padded[padded.length - 1] = (padded[padded.length - 1] ?? 0) ^ FINAL_BIT;
+	return padded;
+}
+function sha3_512(data) {
+	const state = new Array(LANES).fill(0n);
+	const padded = pad(data);
+	const view = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
+	for (let offset = 0; offset < padded.length; offset += RATE_BYTES) {
+		for (let index = 0; index < RATE_BYTES / LANE_BYTES; index++) state[index] = lane(state, index) ^ view.getBigUint64(offset + index * LANE_BYTES, true);
+		keccakF1600(state);
+	}
+	const output = new Uint8Array(OUTPUT_BYTES);
+	const outputView = new DataView(output.buffer);
+	for (let index = 0; index < OUTPUT_BYTES / LANE_BYTES; index++) outputView.setBigUint64(index * LANE_BYTES, lane(state, index), true);
+	return output;
+}
+const encoder = new TextEncoder();
+function sha3_512Hex(input) {
+	return bytesToHex(sha3_512(typeof input === "string" ? encoder.encode(input) : input));
+}
+//#endregion
+//#region src/nav/validate.ts
+const NAV_SERIAL_NUMBER_PATTERN = /^[A-Za-zÁÉÍÓÖŐÚÜŰáéíóöőúüű0-9_/\-\\](?:[A-Za-zÁÉÍÓÖŐÚÜŰáéíóöőúüű0-9/_\-\\ ]*[A-Za-zÁÉÍÓÖŐÚÜŰáéíóöőúüű0-9/_\-\\])?$/;
+const NAV_SOFTWARE_NAME_PATTERN = /^[A-ZÁÉÍÓÖŐÚÜŰa-záéíóöőúüű0-9.\s\-@+_]+$/;
+const NAV_VAT_CATEGORY_PATTERN = /^[A-Za-z0-9áéíóöőúüűÁÉÍÓÖŐÚÜŰ% ]+$/;
+const NAV_REPORT_ID_PATTERN = /^[0-9]{8}_[0-9]{8}_[0-9]+$/;
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const CURRENCY_PATTERN = /^[A-Z]{3}$/;
+const TAXPAYER_ID_PATTERN = /^\d{8}$/;
+const MAX_SERIAL_LENGTH = 50;
+const MAX_SOFTWARE_NAME_LENGTH = 100;
+const MAX_VAT_NAME_LENGTH = 50;
+const MAX_REPORT_ID_LENGTH = 50;
+const MAX_ROW_AMOUNT = 999999999.99;
+const MAX_COUNT = 9999999;
+const MIN_EXCHANGE_RATE = 1;
+const MAX_EXCHANGE_RATE = 1e3;
+const AMOUNT_DECIMALS = 2;
+const RATE_DECIMALS = 4;
+const AMOUNT_TOLERANCE$2 = .005;
+function invalid$1(message, hint) {
+	return new NavReceiptError(message, {
+		category: "validation",
+		hint
+	});
+}
+function assertDate(value, label) {
+	const parsed = DATE_PATTERN.test(value) ? /* @__PURE__ */ new Date(`${value}T00:00:00Z`) : void 0;
+	if (!parsed || Number.isNaN(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== value) throw invalid$1(`A(z) ${label} nem érvényes ÉÉÉÉ-HH-NN dátum: "${value}".`);
+}
+function navDate(value, label = "dátum") {
+	const trimmed = typeof value === "string" ? value.trim() : "";
+	assertDate(trimmed, label);
+	return trimmed;
+}
+function navTaxpayerId(taxNumber) {
+	const digits = typeof taxNumber === "string" ? taxNumber.replace(/[\s-]/g, "") : "";
+	const taxpayerId = digits.slice(0, 8);
+	if (!TAXPAYER_ID_PATTERN.test(taxpayerId) || digits.length !== 8 && digits.length !== 11) throw new NavReceiptError(`Az adószám (${taxNumber}) nem 8 jegyű törzsszám vagy 11 jegyű adószám.`, { category: "configuration" });
+	return taxpayerId;
+}
+function assertSoftwareName(name) {
+	const trimmed = typeof name === "string" ? name.trim() : "";
+	if (trimmed === "" || trimmed.length > MAX_SOFTWARE_NAME_LENGTH || !NAV_SOFTWARE_NAME_PATTERN.test(trimmed)) throw invalid$1(`A nyugtakiállító szoftver neve („${name}”) legfeljebb 100 karakter lehet, és csak betűt, számot, szóközt és a . - @ + _ jeleket tartalmazhatja.`);
+	return trimmed;
+}
+function assertReportId(id) {
+	const trimmed = typeof id === "string" ? id.trim() : "";
+	if (trimmed.length > MAX_REPORT_ID_LENGTH || !NAV_REPORT_ID_PATTERN.test(trimmed)) throw invalid$1(`Az adatszolgáltatás azonosítója („${id}”) nem TÖRZSSZÁM_ÉÉÉÉHHNN_SORSZÁM formátumú.`);
+	return trimmed;
+}
+function assertAmount(value, label, min, max) {
+	if (!Number.isFinite(value) || value < min || value > max) throw invalid$1(`A(z) ${label} (${value}) a megengedett ${min} és ${max} közötti tartományon kívül esik.`);
+	if (decimalPlaces(value) > AMOUNT_DECIMALS) throw invalid$1(`A(z) ${label} (${value}) legfeljebb 2 tizedesjegyet tartalmazhat.`);
+}
+function assertCount(value, label) {
+	if (!Number.isInteger(value) || value < 0 || value > MAX_COUNT) throw invalid$1(`A(z) ${label} (${value}) 0 és ${MAX_COUNT} közötti egész szám legyen.`);
+}
+function assertExchangeRate(currency, rate) {
+	if (currency === "HUF") {
+		if (rate !== null && rate !== 1) throw invalid$1(`Forintos adatszolgáltatásnál az árfolyam null vagy 1 lehet, kapott: ${rate}.`);
+		return;
+	}
+	if (rate === null || !Number.isFinite(rate) || rate < MIN_EXCHANGE_RATE || rate > MAX_EXCHANGE_RATE) throw invalid$1(`Devizás (${currency}) adatszolgáltatásnál az 1 egységre vonatkozó árfolyam 1 és 1000 között legyen, kapott: ${rate}.`, "A NAV csak 1 és 1000 közötti, legfeljebb 4 tizedesjegyű árfolyamot fogad el.");
+	if (decimalPlaces(rate) > RATE_DECIMALS) throw invalid$1(`Az árfolyam (${rate}) legfeljebb 4 tizedesjegyet tartalmazhat.`);
+}
+function assertVatCategories(data) {
+	if (!Array.isArray(data.vatCategories) || data.vatCategories.length === 0) throw invalid$1("Az adatszolgáltatásban legalább egy ÁFA kategóriának szerepelnie kell.");
+	const seen = /* @__PURE__ */ new Set();
+	let sum = 0;
+	for (const row of data.vatCategories) {
+		const name = typeof row.vat === "string" ? row.vat : "";
+		if (name === "" || name.length > MAX_VAT_NAME_LENGTH || !NAV_VAT_CATEGORY_PATTERN.test(name)) throw invalid$1(`Érvénytelen ÁFA kategória név: „${row.vat}”.`);
+		if (seen.has(name)) throw invalid$1(`A(z) „${name}” ÁFA kategória többször szerepel (EPGP0020).`);
+		seen.add(name);
+		assertAmount(row.saleDocument, `„${name}” értékesítési összege`, 0, MAX_ROW_AMOUNT);
+		assertAmount(row.modifyingDocument, `„${name}” módosító összege`, -999999999.99, MAX_ROW_AMOUNT);
+		sum += row.saleDocument + row.modifyingDocument;
+	}
+	return sum;
+}
+function validateNavReceiptData(data, options = {}) {
+	assertDate(data.applicableDate, "tárgynap (applicableDate)");
+	const today = options.today ?? todayInBudapest();
+	if (data.applicableDate > today) throw invalid$1(`A tárgynap (${data.applicableDate}) nem lehet jövőbeli.`);
+	if (typeof data.serialNumber !== "string" || data.serialNumber.length > MAX_SERIAL_LENGTH || !NAV_SERIAL_NUMBER_PATTERN.test(data.serialNumber)) throw invalid$1(`A kezdő nyugtasorszám („${data.serialNumber}”) legfeljebb 50 karakter lehet, és csak betűt, számot, szóközt (belül), valamint - _ / \\ jelet tartalmazhat.`);
+	if (!CURRENCY_PATTERN.test(data.currency)) throw invalid$1(`A pénznem („${data.currency}”) nem háromjegyű, nagybetűs ISO 4217 kód.`);
+	assertExchangeRate(data.currency, data.exchangeRate);
+	const sum = assertVatCategories(data);
+	if (!Number.isFinite(data.total) || decimalPlaces(data.total) > AMOUNT_DECIMALS) throw invalid$1(`A végösszeg (${data.total}) érvénytelen vagy 2-nél több tizedesjegyű.`);
+	if (Math.abs(sum - data.total) > AMOUNT_TOLERANCE$2) throw invalid$1(`A végösszeg (${data.total}) nem egyezik az ÁFA kategóriák összegével (${Math.round(sum * 100) / 100}).`);
+	assertCount(data.numberOfSaleDocument, "nyugták száma (numberOfSaleDocument)");
+	assertCount(data.numberOfModifyingDocument, "módosító bizonylatok száma (numberOfModifyingDocument)");
+	if (data.numberOfSaleDocument === 0 && data.numberOfModifyingDocument === 0) throw invalid$1("A nyugták és a módosító bizonylatok száma közül legalább az egyik nem lehet 0.");
+}
+//#endregion
+//#region src/nav/xml.ts
+const NAV_RECEIPT_NAMESPACE = "http://schemas.nav.gov.hu/NTCA/1.0/receipt";
+const NAV_SERVICE_NAMESPACE = "http://schemas.nav.gov.hu/NTCA/2.0/common/service";
+const NAV_AUTH_NAMESPACE = "http://schemas.nav.gov.hu/NTCA/2.0/common/authservice";
+const NAV_PAGING_NAMESPACE = "http://schemas.nav.gov.hu/NTCA/2.0/common/paging";
+function contextNode(context) {
+	return el("s:context", [el("s:requestId", context.requestId), el("s:timestamp", context.timestamp)]);
+}
+function document(root, children, namespaces = {}) {
+	return buildXmlDocument({
+		root,
+		namespace: NAV_RECEIPT_NAMESPACE,
+		namespaces: {
+			s: NAV_SERVICE_NAMESPACE,
+			...namespaces
+		},
+		children
+	});
+}
+function amount(value) {
+	return roundMoney(value, 2);
+}
+function buildAuthTokenXml(context, auth) {
+	return buildXmlDocument({
+		root: "AuthTokenRequest",
+		namespace: NAV_RECEIPT_NAMESPACE,
+		namespaces: {
+			auth: NAV_AUTH_NAMESPACE,
+			s: NAV_SERVICE_NAMESPACE
+		},
+		children: [
+			contextNode(context),
+			el("auth:auth", [
+				el("auth:login", auth.login),
+				el("auth:passwordHash", auth.passwordHash, { cryptoType: "SHA-512" }),
+				el("auth:taxNumber", auth.taxPayerId),
+				optionalEl("auth:predecessorTaxNumber", auth.predecessorTaxPayerId),
+				el("auth:requestSignature", auth.requestSignature, { cryptoType: "SHA3-512" })
+			]),
+			el("auth:requestVersion", "1.0"),
+			el("auth:headerVersion", "1.0")
+		]
+	});
+}
+function exchangeRateNode(data) {
+	if (data.currency === "HUF" || data.exchangeRate === null) return el("exchangeRate", null, { "xsi:nil": "true" });
+	return el("exchangeRate", roundMoney(data.exchangeRate, 4));
+}
+function receiptBody(data) {
+	return [
+		el("currency", data.currency),
+		exchangeRateNode(data),
+		el("vatCategoryItems", data.vatCategories.map((row) => el("vatCategory", [
+			el("vat", row.vat),
+			el("saleDocument", amount(row.saleDocument)),
+			el("modifyingDocument", amount(row.modifyingDocument))
+		]))),
+		el("total", amount(data.total)),
+		el("numberOfSaleDocument", data.numberOfSaleDocument),
+		el("numberOfModifyingDocument", data.numberOfModifyingDocument)
+	];
+}
+function buildCreateReceiptXml(context, taxPayerId, softwareName, data) {
+	return document("CreateReceiptRequest", [
+		contextNode(context),
+		el("taxPayerId", taxPayerId),
+		el("issuingSoftware", [el("name", softwareName)]),
+		el("applicableDate", data.applicableDate),
+		el("serialNumber", data.serialNumber),
+		...receiptBody(data)
+	], { xsi: XSI_NAMESPACE });
+}
+function buildModifyReceiptXml(context, id, taxPayerId, softwareName, data) {
+	return document("ModifyReceiptRequest", [
+		contextNode(context),
+		el("id", id),
+		el("taxPayerId", taxPayerId),
+		el("issuingSoftware", [el("name", softwareName)]),
+		el("applicableDate", data.applicableDate),
+		...receiptBody(data)
+	], { xsi: XSI_NAMESPACE });
+}
+function buildReceiptListXml(context, taxPayerId, query) {
+	return document("ReceiptListRequest", [
+		contextNode(context),
+		el("paging", [el("page:pageSize", query.pageSize ?? 100), el("page:page", query.page ?? 1)]),
+		el("ordering", [el("property", query.orderBy ?? "APPLICABLE_DATE"), el("direction", query.direction ?? "ASC")]),
+		el("taxPayerId", taxPayerId),
+		el("from", query.from),
+		el("to", query.to)
+	], { page: NAV_PAGING_NAMESPACE });
+}
+function buildReceiptIdXml(root, context, id, taxPayerId) {
+	return document(root, [
+		contextNode(context),
+		el("id", id),
+		el("taxPayerId", taxPayerId)
+	]);
+}
+function buildCreateIssuingSoftwareXml(context, taxPayerId, name) {
+	return document("CreateIssuingSoftwareRequest", [
+		contextNode(context),
+		el("taxPayerId", taxPayerId),
+		el("name", name)
+	]);
+}
+function buildIssuingSoftwareListXml(context, taxPayerId) {
+	return document("IssuingSoftwareListRequest", [contextNode(context), el("taxPayerId", taxPayerId)]);
+}
+function buildContextOnlyXml(root, context) {
+	return document(root, [contextNode(context)]);
+}
+//#endregion
+//#region src/nav/client.ts
+const NAV_RECEIPT_URLS = {
+	test: "https://bv-receipt-if.enyugta.nav.gov.hu/v1",
+	production: "https://receipt-if.enyugta.nav.gov.hu/v1"
+};
+const NAV_DEFAULT_TIMEOUT_MS = 15e3;
+const NAV_MAX_LIST_PAGES = 1e3;
+const OPERATION_PATHS = {
+	authToken: "/auth/token",
+	listReceipts: "/receipt/list",
+	createReceipt: "/receipt/create",
+	receiptDetail: "/receipt/detail",
+	modifyReceipt: "/receipt/modify",
+	invalidateReceipt: "/receipt/invalidate",
+	createIssuingSoftware: "/issuing-software/create",
+	listIssuingSoftware: "/issuing-software/list",
+	vatCategories: "/vat-category/list",
+	currencies: "/currency/list"
+};
+const TOKEN_REFRESH_MARGIN_MS = 3e4;
+const LEGACY_REQUEST_ID_LENGTH = 30;
+const REQUEST_ID_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+const UNBIASED_BYTE_LIMIT = 248;
+const MAX_LOGIN_LENGTH = 50;
+const PASSWORD_HASH_PATTERN = /^[0-9A-Fa-f]{128}$/;
+const UNAUTHORIZED = 401;
+const AMOUNT_TOLERANCE$1 = .005;
+const TIMESTAMP_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?Z$/;
+async function navPasswordHash(password) {
+	return (await digestHex("SHA-512", password)).toUpperCase();
+}
+function navSignatureTimestamp(timestamp) {
+	const match = TIMESTAMP_PATTERN.exec(timestamp);
+	if (!match) throw new NavReceiptError(`Érvénytelen UTC időbélyeg az aláíráshoz: ${timestamp}`, { category: "validation" });
+	return match.slice(1, 7).join("");
+}
+function navRequestSignature(requestId, timestamp, signatureKey) {
+	return sha3_512Hex(`${requestId}${navSignatureTimestamp(timestamp)}${signatureKey}`).toUpperCase();
+}
+function navLegacyRequestId() {
+	let id = "";
+	while (id.length < LEGACY_REQUEST_ID_LENGTH) for (const byte of crypto.getRandomValues(new Uint8Array(LEGACY_REQUEST_ID_LENGTH))) {
+		if (byte >= UNBIASED_BYTE_LIMIT || id.length >= LEGACY_REQUEST_ID_LENGTH) continue;
+		id += REQUEST_ID_ALPHABET[byte % 62];
+	}
+	return id;
+}
+function configuration(message, hint) {
+	return new NavReceiptError(message, {
+		category: "configuration",
+		hint
+	});
+}
+function required(value, label) {
+	if (typeof value !== "string" || value.trim() === "") throw configuration(`Hiányzik a NAV ${label}.`);
+	return value;
+}
+function resolveOptions(options) {
+	if (options.environment !== "test" && options.environment !== "production") throw configuration("Add meg a NAV környezetet: environment: \"test\" vagy \"production\".", "A teszt és az éles NAV rendszer külön technikai felhasználót használ; a kassza nem választ helyetted.");
+	const login = required(options.login, "technikai felhasználó login neve").trim();
+	if (login.length > MAX_LOGIN_LENGTH) throw configuration("A NAV technikai felhasználó login neve legfeljebb 50 karakter lehet.");
+	const passwordHash = options.passwordHash?.trim();
+	if (passwordHash !== void 0 && !PASSWORD_HASH_PATTERN.test(passwordHash)) throw configuration("A passwordHash 128 hexadecimális karakterből álló SHA-512 hash legyen.");
+	if (passwordHash === void 0 && !options.password) throw configuration("Add meg a technikai felhasználó jelszavát (password) vagy annak SHA-512 hash-ét (passwordHash).");
+	const timeoutMs = options.timeoutMs ?? 15e3;
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw configuration(`A timeoutMs pozitív szám legyen, kapott: ${timeoutMs}`);
+	return {
+		baseUrl: (options.baseUrl ?? NAV_RECEIPT_URLS[options.environment]).replace(/\/+$/, ""),
+		login,
+		password: options.password,
+		passwordHash: passwordHash?.toUpperCase(),
+		signatureKey: required(options.signatureKey, "aláírókulcs (signatureKey)"),
+		taxPayerId: navTaxpayerId(required(options.taxNumber, "adószám (taxNumber)")),
+		predecessorTaxPayerId: options.predecessorTaxNumber === void 0 ? void 0 : navTaxpayerId(options.predecessorTaxNumber),
+		softwareName: options.softwareName === void 0 ? void 0 : assertSoftwareName(options.softwareName),
+		timeoutMs
+	};
+}
+function sameReport(existing, data) {
+	return Math.abs(existing.totalAmount - data.total) <= AMOUNT_TOLERANCE$1 && existing.numberOfSaleDocument === data.numberOfSaleDocument && existing.numberOfModifyingDocument === data.numberOfModifyingDocument;
+}
+function createNavReceiptClient(options) {
+	const resolved = resolveOptions(options);
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	if (typeof fetchImpl !== "function") throw configuration("Nem található fetch implementáció. Add meg a fetch opciót.");
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	const allowWrite = options.allowWrite === true;
+	let cachedToken;
+	let pendingToken;
+	let passwordHashPromise;
+	const passwordHash = () => {
+		if (resolved.passwordHash !== void 0) return Promise.resolve(resolved.passwordHash);
+		passwordHashPromise ??= navPasswordHash(resolved.password ?? "");
+		return passwordHashPromise;
+	};
+	async function send(operation, xml, signal, token) {
+		signal?.throwIfAborted();
+		const timeout = AbortSignal.timeout(resolved.timeoutMs);
+		const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+		const headers = {
+			"content-type": "application/xml; charset=UTF-8",
+			accept: "application/xml"
+		};
+		if (token !== void 0) headers.authorization = `Bearer ${token}`;
+		try {
+			const response = await fetchImpl(`${resolved.baseUrl}${OPERATION_PATHS[operation]}`, {
+				method: "POST",
+				headers,
+				body: xml,
+				signal: combined
+			});
+			return {
+				status: response.status,
+				body: await response.text()
+			};
+		} catch (error) {
+			if (signal?.aborted) throw signal.reason;
+			if (timeout.aborted) throw new NavReceiptError(`A NAV nem válaszolt ${resolved.timeoutMs} ms alatt (${operation}).`, {
+				category: "timeout",
+				operation,
+				cause: error
+			});
+			throw new NavReceiptError(`Hálózati hiba a NAV elérésekor (${operation}).`, {
+				category: "network",
+				operation,
+				cause: error
+			});
+		}
+	}
+	async function requestToken(signal) {
+		const timestamp = now().toISOString();
+		const requestId = navLegacyRequestId();
+		const response = await send("authToken", buildAuthTokenXml({
+			requestId,
+			timestamp
+		}, {
+			login: resolved.login,
+			passwordHash: await passwordHash(),
+			taxPayerId: resolved.taxPayerId,
+			predecessorTaxPayerId: resolved.predecessorTaxPayerId,
+			requestSignature: navRequestSignature(requestId, timestamp, resolved.signatureKey)
+		}), signal, void 0);
+		const token = parseAuthTokenResponse(parseNavResponse("authToken", "AuthTokenResponse", response.status, response.body));
+		const validUntil = Date.parse(token.validTo);
+		cachedToken = {
+			value: token,
+			expiresAt: Number.isFinite(validUntil) ? validUntil - TOKEN_REFRESH_MARGIN_MS : 0
+		};
+		return token;
+	}
+	async function authenticate(requestOptions = {}) {
+		pendingToken ??= requestToken(requestOptions.signal).finally(() => {
+			pendingToken = void 0;
+		});
+		return pendingToken;
+	}
+	async function currentToken(signal) {
+		if (cachedToken && cachedToken.expiresAt > now().getTime()) return cachedToken.value.token;
+		return (await authenticate({ signal })).token;
+	}
+	function context() {
+		return {
+			requestId: crypto.randomUUID(),
+			timestamp: now().toISOString()
+		};
+	}
+	async function call(operation, expectedRoot, build, parse, requestOptions) {
+		for (let attempt = 1;; attempt++) {
+			const token = await currentToken(requestOptions.signal);
+			const response = await send(operation, build(context()), requestOptions.signal, token);
+			if (response.status === UNAUTHORIZED && attempt === 1) {
+				cachedToken = void 0;
+				continue;
+			}
+			return parse(parseNavResponse(operation, expectedRoot, response.status, response.body));
+		}
+	}
+	function assertWritable(operation) {
+		if (allowWrite) return;
+		throw new NavReceiptError("A NAV kliens csak olvasásra van beállítva, ezért nem küld adatot.", {
+			category: "write_blocked",
+			operation,
+			hint: "Ha a Számlázz.hu már beküldi a nyugtáidat, ne küldd be te is, mert az dupla adatszolgáltatás. Ha biztosan neked kell beküldeni (például papír nyugtatömb), add meg az allowWrite: true opciót."
+		});
+	}
+	function softwareFor(name) {
+		const software = name === void 0 ? resolved.softwareName : assertSoftwareName(name);
+		if (software === void 0) throw configuration("Add meg a nyugtakiállító szoftver nevét (softwareName), ahogy a NAV-nál rögzítve van.");
+		return software;
+	}
+	function query(input) {
+		const from = navDate(input.from, "lekérdezés kezdete (from)");
+		const to = navDate(input.to, "lekérdezés vége (to)");
+		if (to < from) throw new NavReceiptError(`A lekérdezés vége (${to}) nem lehet korábbi a kezdeténél (${from}).`, {
+			category: "validation",
+			operation: "listReceipts"
+		});
+		const pageSize = input.pageSize ?? 100;
+		const page = input.page ?? 1;
+		if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) throw new NavReceiptError(`A pageSize 1 és 100 közötti egész szám legyen, kapott: ${pageSize}`, {
+			category: "validation",
+			operation: "listReceipts"
+		});
+		if (!Number.isInteger(page) || page < 1) throw new NavReceiptError(`A page legalább 1 egész szám legyen, kapott: ${page}`, {
+			category: "validation",
+			operation: "listReceipts"
+		});
+		return {
+			...input,
+			from,
+			to,
+			page,
+			pageSize
+		};
+	}
+	async function listReports(input, requestOptions = {}) {
+		const checked = query(input);
+		return call("listReceipts", "ReceiptListResponse", (requestContext) => buildReceiptListXml(requestContext, resolved.taxPayerId, checked), parseReceiptListResponse, requestOptions);
+	}
+	async function listAllReports(input, requestOptions = {}) {
+		const items = [];
+		for (let page = 1; page <= NAV_MAX_LIST_PAGES; page++) {
+			const result = await listReports({
+				...input,
+				page,
+				pageSize: 100
+			}, requestOptions);
+			items.push(...result.items);
+			if (result.items.length === 0 || items.length >= result.totalRowCount) return items;
+		}
+		throw new NavReceiptError(`A NAV listázás ${NAV_MAX_LIST_PAGES} oldal után sem ért véget; szűkítsd az időszakot.`, {
+			category: "unexpected_response",
+			operation: "listReceipts"
+		});
+	}
+	async function submitReport(data, submitOptions = {}) {
+		assertWritable("createReceipt");
+		const software = softwareFor(submitOptions.softwareName);
+		validateNavReceiptData(data, { today: todayInBudapest(now()) });
+		const existing = (await listAllReports({
+			from: data.applicableDate,
+			to: data.applicableDate
+		}, { signal: submitOptions.signal })).find((item) => item.status === "RECORDED" && item.serialNumber === data.serialNumber);
+		if (existing) {
+			if (sameReport(existing, data)) return {
+				id: existing.id,
+				created: false,
+				softwareName: existing.softwareName
+			};
+			throw new NavReceiptError(`Erre a tárgynapra (${data.applicableDate}) és kezdő sorszámra (${data.serialNumber}) már van rögzített adatszolgáltatás (${existing.id}) eltérő adatokkal.`, {
+				category: "conflict",
+				operation: "createReceipt",
+				details: {
+					existingId: existing.id,
+					existingSoftware: existing.softwareName
+				},
+				hint: "Ha a korábbi adat hibás, javítsd a modifyReport(id, …) hívással; ha más szoftver küldte be (például a Számlázz.hu), ne küldd be újra."
+			});
+		}
+		return {
+			id: await call("createReceipt", "CreateReceiptResponse", (requestContext) => buildCreateReceiptXml(requestContext, resolved.taxPayerId, software, data), (root) => parseIdResponse(root, "createReceipt"), { signal: submitOptions.signal }),
+			created: true,
+			softwareName: software
+		};
+	}
+	async function modifyReport(id, data, submitOptions = {}) {
+		assertWritable("modifyReceipt");
+		const reportId = assertReportId(id);
+		const software = softwareFor(submitOptions.softwareName);
+		validateNavReceiptData(data, { today: todayInBudapest(now()) });
+		return { id: await call("modifyReceipt", "ModifyReceiptResponse", (requestContext) => buildModifyReceiptXml(requestContext, reportId, resolved.taxPayerId, software, data), (root) => parseIdResponse(root, "modifyReceipt"), { signal: submitOptions.signal }) };
+	}
+	async function invalidateReport(id, requestOptions = {}) {
+		assertWritable("invalidateReceipt");
+		const reportId = assertReportId(id);
+		await call("invalidateReceipt", "InvalidateReceiptResponse", (requestContext) => buildReceiptIdXml("InvalidateReceiptRequest", requestContext, reportId, resolved.taxPayerId), () => void 0, requestOptions);
+	}
+	function listSoftware(requestOptions = {}) {
+		return call("listIssuingSoftware", "IssuingSoftwareListResponse", (requestContext) => buildIssuingSoftwareListXml(requestContext, resolved.taxPayerId), parseIssuingSoftwareListResponse, requestOptions);
+	}
+	async function registerSoftware(name, requestOptions = {}) {
+		assertWritable("createIssuingSoftware");
+		const software = softwareFor(name);
+		if ((await listSoftware(requestOptions)).includes(software)) return { created: false };
+		await call("createIssuingSoftware", "CreateIssuingSoftwareResponse", (requestContext) => buildCreateIssuingSoftwareXml(requestContext, resolved.taxPayerId, software), () => void 0, requestOptions);
+		return { created: true };
+	}
+	return {
+		environment: options.environment,
+		taxPayerId: resolved.taxPayerId,
+		canWrite: allowWrite,
+		authenticate,
+		listReports,
+		listAllReports,
+		getReport: async (id, requestOptions = {}) => {
+			const reportId = assertReportId(id);
+			return call("receiptDetail", "ReceiptDetailResponse", (requestContext) => buildReceiptIdXml("ReceiptDetailRequest", requestContext, reportId, resolved.taxPayerId), parseReceiptDetailResponse, requestOptions);
+		},
+		submitReport,
+		modifyReport,
+		invalidateReport,
+		registerSoftware,
+		listSoftware,
+		vatCategories: (requestOptions = {}) => call("vatCategories", "VatCategoryResponse", (requestContext) => buildContextOnlyXml("VatCategoryRequest", requestContext), parseVatCategoryResponse, requestOptions),
+		currencies: (requestOptions = {}) => call("currencies", "CurrencyResponse", (requestContext) => buildContextOnlyXml("CurrencyRequest", requestContext), parseCurrencyResponse, requestOptions)
+	};
+}
+//#endregion
+//#region src/nav/paper.ts
+function invalid(message) {
+	return new NavReceiptError(message, { category: "validation" });
+}
+function categoryOrder(name) {
+	const index = NAV_VAT_CATEGORIES.indexOf(name);
+	return index === -1 ? NAV_VAT_CATEGORIES.length : index;
+}
+function paperReceiptReport(day) {
+	if (!Array.isArray(day.entries) || day.entries.length === 0) throw invalid("A papír nyugtatömb napi jelentéséhez legalább egy tétel kell.");
+	const currency = (day.currency ?? "HUF").trim().toUpperCase();
+	const totals = /* @__PURE__ */ new Map();
+	const sales = /* @__PURE__ */ new Set();
+	const modifying = /* @__PURE__ */ new Set();
+	for (const entry of day.entries) {
+		const number = typeof entry.number === "string" ? entry.number.trim() : "";
+		if (number === "") throw invalid("Minden papír nyugtatételhez add meg a nyugta sorszámát.");
+		if (!Number.isFinite(entry.gross)) throw invalid(`A(z) ${number} nyugta bruttó összege érvénytelen: ${entry.gross}`);
+		if (entry.modifying !== true && entry.gross < 0) throw invalid(`A(z) ${number} eladási nyugta összege nem lehet negatív; a visszavételt jelöld modifying: true értékkel.`);
+		const row = totals.get(entry.vat) ?? {
+			sale: 0,
+			modifying: 0
+		};
+		if (entry.modifying === true) {
+			row.modifying += entry.gross;
+			modifying.add(number);
+		} else {
+			row.sale += entry.gross;
+			sales.add(number);
+		}
+		totals.set(entry.vat, row);
+	}
+	const overlap = [...sales].filter((number) => modifying.has(number));
+	if (overlap.length > 0) throw invalid(`Ugyanaz a sorszám nem lehet egyszerre eladási és módosító bizonylat: ${overlap.join(", ")}.`);
+	const vatCategories = [...totals.entries()].map(([vat, row]) => ({
+		vat,
+		saleDocument: roundMoney(row.sale, 2),
+		modifyingDocument: roundMoney(row.modifying, 2)
+	})).sort((a, b) => categoryOrder(a.vat) - categoryOrder(b.vat) || a.vat.localeCompare(b.vat));
+	const numbers = [...sales, ...modifying].sort(compareReceiptNumbers);
+	return {
+		applicableDate: toAgentDate(day.applicableDate),
+		serialNumber: numbers[0] ?? "",
+		currency,
+		exchangeRate: currency === "HUF" ? null : day.exchangeRate ?? null,
+		vatCategories,
+		total: roundMoney(vatCategories.reduce((sum, row) => sum + row.saleDocument + row.modifyingDocument, 0), 2),
+		numberOfSaleDocument: sales.size,
+		numberOfModifyingDocument: modifying.size
+	};
+}
+//#endregion
+//#region src/nav/reconcile.ts
+const AMOUNT_TOLERANCE = .005;
+function keyOf(applicableDate, serialNumber) {
+	return JSON.stringify([applicableDate, serialNumber]);
+}
+function differences(local, remote) {
+	const found = [];
+	if (Math.abs(roundMoney(local.total, 2) - remote.totalAmount) > AMOUNT_TOLERANCE) found.push(`végösszeg: helyi ${local.total}, NAV ${remote.totalAmount}`);
+	if (local.numberOfSaleDocument !== remote.numberOfSaleDocument) found.push(`nyugták száma: helyi ${local.numberOfSaleDocument}, NAV ${remote.numberOfSaleDocument}`);
+	if (local.numberOfModifyingDocument !== remote.numberOfModifyingDocument) found.push(`módosító bizonylatok száma: helyi ${local.numberOfModifyingDocument}, NAV ${remote.numberOfModifyingDocument}`);
+	return found;
+}
+function reconcileNavReports(local, remote) {
+	const recorded = /* @__PURE__ */ new Map();
+	for (const item of remote) {
+		if (item.status !== "RECORDED") continue;
+		const key = keyOf(item.applicableDate, item.serialNumber);
+		recorded.set(key, [...recorded.get(key) ?? [], item]);
+	}
+	const matched = [];
+	const mismatched = [];
+	const missing = [];
+	for (const report of local) {
+		const key = keyOf(report.applicableDate, report.serialNumber);
+		const counterpart = recorded.get(key)?.shift();
+		if (!counterpart) {
+			missing.push(report);
+			continue;
+		}
+		const found = differences(report, counterpart);
+		if (found.length === 0) matched.push({
+			local: report,
+			remote: counterpart
+		});
+		else mismatched.push({
+			local: report,
+			remote: counterpart,
+			differences: found
+		});
+	}
+	return {
+		matched,
+		mismatched,
+		missing,
+		unexpected: [...recorded.values()].flat()
+	};
+}
+//#endregion
+export { NAV_AUTH_NAMESPACE, NAV_DEFAULT_TIMEOUT_MS, NAV_MAX_LIST_PAGES, NAV_PAGING_NAMESPACE, NAV_RECEIPT_ERROR_CODES, NAV_RECEIPT_NAMESPACE, NAV_RECEIPT_URLS, NAV_REPORT_ID_PATTERN, NAV_SERIAL_NUMBER_PATTERN, NAV_SERVICE_NAMESPACE, NAV_SOFTWARE_NAME_PATTERN, NAV_VAT_CATEGORY_PATTERN, NavReceiptError, buildAuthTokenXml, buildContextOnlyXml, buildCreateIssuingSoftwareXml, buildCreateReceiptXml, buildIssuingSoftwareListXml, buildModifyReceiptXml, buildReceiptIdXml, buildReceiptListXml, createNavReceiptClient, isNavReceiptError, navLegacyRequestId, navPasswordHash, navRequestSignature, navSignatureTimestamp, navTaxpayerId, paperReceiptReport, parseNavResponse, reconcileNavReports, sha3_512, sha3_512Hex, validateNavReceiptData };