kassza 0.12.0 → 0.14.0

package/dist/issue-DMA1Nbr1.js

@@ -0,0 +1,905 @@
+import { r as SzamlazzError } from "./errors-DtN4g5Z9.js";
+import { a as unknownOutcomeError, i as resolveRecoveryDelay, n as isUncertainOutcome, r as recoverAfterFailure } from "./once-CqqZxsXG.js";
+import { r as roundMoney } from "./rounding-BLyHjjI5.js";
+import { a as isVatRate, i as isHuf } from "./vat-v_dcWCto.js";
+import { n as calculateInvoiceItem, t as allocateRefund } from "./money-Cw457SD6.js";
+import { l as RECEIPT_ONLY_VAT_CODES, n as calculateReceiptItems } from "./create-CflXrPip.js";
+//#region src/core/once-guard.ts
+const ONCE_LOCK_KEY_PREFIX = "szamlazz:once:";
+const DEFAULT_LOCK_TTL_SECONDS = 600;
+const DEFAULT_LOCK_WAIT_MS = 1e4;
+const inflight = /* @__PURE__ */ new Map();
+function configurationError(message) {
+	return new SzamlazzError(message, { category: "configuration" });
+}
+function resolveTtl(value) {
+	if (value === void 0) return 600;
+	if (!Number.isFinite(value) || value < 1) throw configurationError(`A lockTtlSeconds értéke legalább 1 másodperc legyen, kapott: ${String(value)}`);
+	return Math.ceil(value);
+}
+function resolveWait(value) {
+	if (value === void 0) return DEFAULT_LOCK_WAIT_MS;
+	if (!Number.isFinite(value) || value < 0) throw configurationError(`A lockWaitMs értéke nemnegatív szám legyen, kapott: ${String(value)}`);
+	return value;
+}
+function resolveFailureMode(value) {
+	if (value === void 0 || value === "throw" || value === "proceed") return value ?? "throw";
+	throw configurationError(`A lockFailure értéke 'throw' vagy 'proceed' lehet, kapott: ${String(value)}`);
+}
+const encoder = new TextEncoder();
+async function onceLockKey(scope, key) {
+	const digest = await crypto.subtle.digest("SHA-256", encoder.encode(`${scope}\n${key}`));
+	const hex = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0"));
+	return `${ONCE_LOCK_KEY_PREFIX}${hex.join("")}`;
+}
+function inProgressError(reference, waitMs) {
+	return new SzamlazzError(`Egy másik folyamat éppen kiállítja ezt a bizonylatot (${reference}), ${Math.ceil(waitMs / 1e3)} másodperc várakozás után sem végzett.`, {
+		category: "in_progress",
+		details: { reference },
+		hint: "Ne állítsd ki kézzel. Néhány másodperc múlva hívd újra ugyanígy a createOnce-t: a zár felszabadulása után visszakeresi a bizonylatot. Webhookban adj vissza 5xx választ, hogy a szolgáltató később újraküldje."
+	});
+}
+function lockUnavailableError(reference, error) {
+	return new SzamlazzError(`A createOnce zár tárolója nem érhető el, ezért a kassza nem állította ki a bizonylatot (${reference}).`, {
+		category: "store_unavailable",
+		details: { reference },
+		cause: error,
+		hint: "Állítsd helyre a tárolót (például a Redist), és hívd újra. Ha zár nélkül is ki akarod állítani, add meg a lockFailure: 'proceed' beállítást."
+	});
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason);
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+async function releaseLock(store, lockKey, token, warn) {
+	try {
+		if (store.deleteIfEquals) {
+			await store.deleteIfEquals(lockKey, token);
+			return;
+		}
+		if (await store.get(lockKey) === token) await store.delete(lockKey);
+	} catch (error) {
+		warn?.({
+			kind: "lock",
+			message: "A createOnce zárat nem sikerült felszabadítani. A zár a lejárati ideje végén magától megszűnik, addig az azonos bizonylatra érkező hívások in_progress hibát kapnak.",
+			error,
+			operation: "release"
+		});
+	}
+}
+async function runLocked(guard, key, options, recheck, run) {
+	const store = options.lock === false ? void 0 : options.lock ?? guard.lock;
+	if (!store) return run(recheck);
+	const setIfAbsent = store.setIfAbsent?.bind(store);
+	if (!setIfAbsent) throw configurationError("A createOnce zárához olyan tároló kell, amely támogatja a setIfAbsent műveletet (például a kassza/stores Redis adapterei vagy a Durable Object tároló). A Cloudflare KV erre nem alkalmas.");
+	const ttlSeconds = resolveTtl(options.lockTtlSeconds);
+	const waitMs = resolveWait(options.lockWaitMs);
+	const failureMode = resolveFailureMode(options.lockFailure);
+	const lockKey = await onceLockKey(guard.scope, key);
+	const token = crypto.randomUUID();
+	const deadline = Date.now() + waitMs;
+	let waited = false;
+	for (;;) {
+		let acquired;
+		try {
+			acquired = await setIfAbsent(lockKey, token, ttlSeconds);
+		} catch (error) {
+			if (failureMode === "throw") throw lockUnavailableError(key, error);
+			guard.warn?.({
+				kind: "lock",
+				message: "A createOnce zár tárolója nem érhető el, a kassza zár nélkül folytatja (lockFailure: proceed). A folyamatok közötti dupla kiállítás elleni védelem most nem él.",
+				error,
+				operation: "setIfAbsent"
+			});
+			return run(recheck || waited);
+		}
+		if (acquired) break;
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) throw inProgressError(key, waitMs);
+		waited = true;
+		await sleep(Math.min(500, remaining), options.signal);
+	}
+	try {
+		return await run(recheck || waited);
+	} finally {
+		await releaseLock(store, lockKey, token, guard.warn);
+	}
+}
+function isSharedFailure(error) {
+	return error instanceof SzamlazzError && !isUncertainOutcome(error);
+}
+async function guardOnce(guard, key, options, run, joined) {
+	if (!guard) return run(false);
+	const id = `${guard.scope}\n${key}`;
+	let recheck = false;
+	for (;;) {
+		const pending = inflight.get(id);
+		if (!pending) break;
+		try {
+			return joined(await pending);
+		} catch (error) {
+			if (isSharedFailure(error)) throw error;
+			recheck = true;
+		}
+		options.signal?.throwIfAborted();
+	}
+	const leader = runLocked(guard, key, options, recheck, run);
+	inflight.set(id, leader);
+	try {
+		return await leader;
+	} finally {
+		if (inflight.get(id) === leader) inflight.delete(id);
+	}
+}
+//#endregion
+//#region src/invoices/create-once.ts
+const EXTERNAL_ID_SUFFIXES = {
+	invoice: "",
+	proforma: "/D",
+	advance: "/E",
+	final: "/V",
+	corrective: "/H",
+	deliveryNote: "/SZL"
+};
+function invoiceOnceExternalId(type, orderNumber) {
+	return `${orderNumber}${EXTERNAL_ID_SUFFIXES[type]}`;
+}
+function requireOrderNumber(input) {
+	const orderNumber = input.orderNumber?.trim();
+	if (!orderNumber) throw new SzamlazzError("A createOnce-hoz add meg a rendelésszámot (orderNumber), ez azonosítja a bizonylatot.", { category: "validation" });
+	return orderNumber;
+}
+function sameDocumentType(found, requested) {
+	return found === requested || found === "reversal" || found === "unknown";
+}
+async function lookup(api, externalId, orderNumber, type, options) {
+	const query = { includePdf: false };
+	const byExternalId = await api.find({ externalId }, query, options);
+	if (byExternalId) return byExternalId;
+	if (options.matchOrderNumber === false) return null;
+	const byOrderNumber = await api.find({ orderNumber }, query, options);
+	if (byOrderNumber && sameDocumentType(byOrderNumber.header.type, type)) return byOrderNumber;
+	return null;
+}
+function existingResult(details, externalId, created) {
+	return {
+		number: details.header.number,
+		created,
+		externalId,
+		details
+	};
+}
+function invoiceOnceGuardKey(type, orderNumber, externalId, options) {
+	if (options.matchOrderNumber === false) return `invoice:externalId:${externalId}`;
+	return `invoice:order:${type}:${orderNumber}`;
+}
+async function createInvoiceOnce(api, input, options = {}, guard) {
+	const orderNumber = requireOrderNumber(input);
+	const type = input.type ?? "invoice";
+	const externalId = input.externalId?.trim() || invoiceOnceExternalId(type, orderNumber);
+	const delayMs = resolveRecoveryDelay(options.recoveryDelayMs);
+	const normalized = {
+		...input,
+		orderNumber,
+		externalId
+	};
+	const run = async (recheck) => {
+		if (recheck || options.lookupFirst !== false) {
+			const existing = await lookup(api, externalId, orderNumber, type, options);
+			if (existing) return existingResult(existing, externalId, false);
+		}
+		try {
+			const invoice = await api.create(normalized, options);
+			return {
+				number: invoice.number,
+				created: true,
+				externalId,
+				invoice
+			};
+		} catch (error) {
+			if (!isUncertainOutcome(error)) throw error;
+			const state = {};
+			const recovered = await recoverAfterFailure(() => lookup(api, externalId, orderNumber, type, options), delayMs, options.signal, state);
+			if (recovered) return existingResult(recovered, externalId, error.category !== "duplicate");
+			if (error.category === "duplicate" && !state.lookupError) throw error;
+			throw unknownOutcomeError(error, `${orderNumber} rendelés`, { lookupError: state.lookupError });
+		}
+	};
+	return guardOnce(guard, invoiceOnceGuardKey(type, orderNumber, externalId, options), options, run, (result) => ({
+		...result,
+		created: false
+	}));
+}
+//#endregion
+//#region src/documents/choose.ts
+const RECEIPT_MAX_GROSS_HUF = 9e5;
+const forintFormatter = new Intl.NumberFormat("hu-HU", { maximumFractionDigits: 2 });
+function validation$3(message) {
+	return new SzamlazzError(message, { category: "validation" });
+}
+function grossInHuf(input) {
+	if (!Number.isFinite(input.grossTotal) || input.grossTotal < 0) throw validation$3(`A bruttó végösszeg (grossTotal) nemnegatív szám legyen, kapott: ${input.grossTotal}`);
+	if (isHuf(input.currency)) return input.grossTotal;
+	const rate = input.exchangeRate;
+	if (rate === void 0 || !Number.isFinite(rate) || rate <= 0) throw validation$3(`Devizás (${input.currency}) összegnél add meg az árfolyamot (exchangeRate), mert a 900 000 Ft-os határt forintban kell nézni.`);
+	return input.grossTotal * rate;
+}
+function isBusinessBuyer(buyer) {
+	if (!buyer) return false;
+	return buyer.isBusiness === true || Boolean(buyer.taxNumber?.trim()) || Boolean(buyer.euTaxNumber?.trim());
+}
+function chooseDocument(input) {
+	const grossTotalHuf = grossInHuf(input);
+	const invoiceReasons = [];
+	if (isBusinessBuyer(input.buyer)) invoiceReasons.push("A vevő adóalany vagy jogi személy (adószámot adott meg), ezért számlát kell kiállítani.");
+	if (grossTotalHuf >= 9e5) invoiceReasons.push(`Az ellenérték (${forintFormatter.format(grossTotalHuf)} Ft) eléri a 900 000 Ft-ot, ezért számlát kell kiállítani.`);
+	if (input.paidByFulfillment === false) invoiceReasons.push("A teljes ellenértéket nem fizetik meg legkésőbb a teljesítésig, ezért számlát kell kiállítani.");
+	if (input.invoiceRequested === true) invoiceReasons.push("A vevő számlát kér, ezért számlát kell kiállítani.");
+	if (invoiceReasons.length > 0) return {
+		type: "invoice",
+		reasons: invoiceReasons,
+		grossTotalHuf
+	};
+	if (input.cashRegisterRequired === true) return {
+		type: "cash-register",
+		reasons: ["A tevékenység online pénztárgép- vagy e-pénztárgép-köteles, ezért nyugtát csak pénztárgéppel lehet adni, számítógéppel előállítottat (Számla Agent) nem.", "Ha a kasszával szeretnéd bizonylatolni, állíts ki számlát a vevő nevére."],
+		grossTotalHuf
+	};
+	return {
+		type: "receipt",
+		reasons: ["A vevő nem adóalany és nem jogi személy, az ellenérték 900 000 Ft alatt van, a teljesítésig kifizetik, és nem kér számlát, ezért nyugta adható."],
+		grossTotalHuf
+	};
+}
+//#endregion
+//#region src/receipts/convert.ts
+const receiptOnlyCodes = new Set(RECEIPT_ONLY_VAT_CODES);
+function validation$2(message, hint) {
+	return new SzamlazzError(message, {
+		category: "validation",
+		hint
+	});
+}
+function conversionExternalId(receiptNumber) {
+	return `CONV/${receiptNumber}`;
+}
+function invoiceVat(item, mapping) {
+	if (typeof item.vat === "string" && receiptOnlyCodes.has(item.vat)) {
+		const mapped = mapping?.[item.vat];
+		if (mapped === void 0) throw validation$2(`A(z) „${item.name}” tétel áfakódja (${item.vat}) csak nyugtán használható, számlán nincs automatikus megfelelője.`, "Add meg a számlán használandó áfakulcsot a vatMapping opcióban, a könyvelőddel egyeztetve.");
+		return mapped;
+	}
+	return item.vat;
+}
+function receiptItemsToInvoiceItems(receipt, mapping) {
+	return receipt.items.map((item) => {
+		if (!(item.quantity > 0)) throw validation$2(`A(z) „${item.name}” tétel mennyisége nem pozitív, a nyugta nem alakítható számlává.`);
+		return {
+			name: item.name,
+			identifier: item.identifier,
+			quantity: item.quantity,
+			unit: item.unit || void 0,
+			grossUnitPrice: item.grossAmount / item.quantity,
+			vat: invoiceVat(item, mapping)
+		};
+	});
+}
+function conversionComment(receipt, reversal, extra) {
+	const reversalPart = reversal ? `, sztornó: ${reversal.number}` : "";
+	const base = `A(z) ${receipt.number} nyugta alapján kiállított számla (a nyugta sztornózva${reversalPart}).`;
+	return extra?.trim() ? `${base} ${extra.trim()}` : base;
+}
+async function convertReceiptToInvoice(api, input, options = {}) {
+	const receiptNumber = input.receiptNumber?.trim();
+	if (!receiptNumber) throw validation$2("Add meg az átalakítandó nyugta számát (receiptNumber).");
+	const receipt = await api.receipts.get({
+		receiptNumber,
+		downloadPdf: false
+	}, options);
+	if (receipt.type !== "receipt") throw validation$2(`A(z) ${receiptNumber} sztornó nyugta, számlává nem alakítható.`);
+	const items = receiptItemsToInvoiceItems(receipt, input.vatMapping);
+	const externalId = conversionExternalId(receipt.number);
+	const orderNumber = input.orderNumber?.trim() || receipt.orderNumber || `CONV-${receipt.number}`;
+	const existing = await api.invoices.find({ externalId }, { includePdf: false }, options);
+	if (existing) return {
+		receipt,
+		invoice: {
+			number: existing.header.number,
+			created: false,
+			externalId,
+			details: existing
+		}
+	};
+	let reversal;
+	if (receipt.isReversed) {
+		if (input.allowAlreadyReversed !== true) throw validation$2(`A(z) ${receipt.number} nyugta már sztornózva van, ezért nem állítok ki rá számlát.`, "Ha a sztornót egy korábbi, félbeszakadt átalakítás végezte, hívd újra allowAlreadyReversed: true beállítással.");
+	} else reversal = await api.receipts.reverse({
+		receiptNumber: receipt.number,
+		callId: `CONV-${receipt.number}`,
+		downloadPdf: false
+	}, options);
+	const invoice = await createInvoiceOnce(api.invoices, {
+		buyer: input.buyer,
+		items,
+		orderNumber,
+		externalId,
+		paid: true,
+		paymentMethod: receipt.paymentMethod,
+		currency: receipt.currency,
+		...isHuf(receipt.currency) ? {} : {
+			exchangeRate: receipt.exchangeRate,
+			exchangeBank: receipt.exchangeBank
+		},
+		fulfillmentDate: receipt.issueDate || void 0,
+		prefix: input.prefix,
+		language: input.language,
+		template: input.template,
+		seller: input.seller,
+		eInvoice: input.eInvoice,
+		downloadPdf: input.downloadPdf,
+		comment: conversionComment(receipt, reversal, input.comment)
+	}, {
+		...options,
+		lookupFirst: false,
+		matchOrderNumber: false
+	});
+	return {
+		receipt,
+		reversal,
+		invoice
+	};
+}
+//#endregion
+//#region src/payments/partial-refund.ts
+const CORRECTION_SUFFIX = "/R-";
+const MAX_PLAIN_REFUND_KEY = 24;
+const AMOUNT_TOLERANCE$1 = .005;
+function validation$1(message, hint) {
+	return new SzamlazzError(message, {
+		category: "validation",
+		hint
+	});
+}
+function skipped$1(orderNumber, reason) {
+	return {
+		kind: "skipped",
+		orderNumber,
+		reason
+	};
+}
+async function refundKey(id) {
+	if (id.length <= MAX_PLAIN_REFUND_KEY && /^[A-Za-z0-9_.:-]+$/.test(id)) return id;
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(id));
+	return Array.from(new Uint8Array(digest).slice(0, 8), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function correctionExternalId(orderNumber, refundId) {
+	return `${orderNumber}${CORRECTION_SUFFIX}${await refundKey(refundId)}`;
+}
+function decimalsFor(currency) {
+	return isHuf(currency) ? 0 : 2;
+}
+function vatOfItem(item) {
+	if (item.vatCode && isVatRate(item.vatCode)) return item.vatCode;
+	return isVatRate(item.vat) ? item.vat : void 0;
+}
+function refundableItems(details) {
+	const items = [];
+	for (const item of details.items) {
+		const vat = vatOfItem(item);
+		if (vat === void 0 || item.grossAmount < 0) return void 0;
+		items.push({
+			name: item.name,
+			vat,
+			grossAmount: item.grossAmount,
+			...item.unit === void 0 ? {} : { unit: item.unit },
+			...item.identifier === void 0 ? {} : { identifier: item.identifier }
+		});
+	}
+	return items.length > 0 ? items : void 0;
+}
+function receiptItems(receipt) {
+	return receipt.items.map((item) => ({
+		name: item.name,
+		vat: item.vat,
+		grossAmount: item.grossAmount,
+		...item.unit === void 0 ? {} : { unit: item.unit }
+	}));
+}
+function buyerOf(details) {
+	const { buyer } = details;
+	const address = buyer.address;
+	if (!buyer.name || !address?.zip || !address.city || !address.address) return void 0;
+	return {
+		name: buyer.name,
+		zip: address.zip,
+		city: address.city,
+		address: address.address,
+		country: address.country,
+		email: buyer.email,
+		taxNumber: buyer.taxNumber,
+		groupTaxNumber: buyer.groupTaxNumber,
+		euTaxNumber: buyer.euTaxNumber,
+		identifier: buyer.identifier
+	};
+}
+function sameCurrency(a, b) {
+	if (isHuf(a) && isHuf(b)) return true;
+	return a?.trim().toUpperCase() === b?.trim().toUpperCase();
+}
+function assertRefunds(refunds, currency, documentNumber) {
+	for (const refund of refunds) if (!sameCurrency(refund.amount.currency, currency)) throw validation$1(`A(z) ${refund.id} visszatérítés pénzneme (${refund.amount.currency}) eltér a(z) ${documentNumber} bizonylatétól (${currency ?? "HUF"}).`);
+}
+function proposal(orderNumber, document, documentNumber, items, refunds, currency, reason) {
+	return {
+		kind: "refund-proposal",
+		orderNumber,
+		document,
+		documentNumber,
+		refunds: refunds.map((refund) => ({
+			refundId: refund.id,
+			grossTotal: refund.amount.value,
+			items: allocateRefund(items, refund.amount.value, {
+				decimals: decimalsFor(currency),
+				refundedBefore: refund.refundedBefore
+			})
+		})),
+		reason
+	};
+}
+function allocationItems(allocations) {
+	return allocations.map((allocation) => ({
+		name: allocation.name,
+		quantity: -1,
+		unit: allocation.unit,
+		identifier: allocation.identifier,
+		grossUnitPrice: allocation.grossAmount,
+		vat: allocation.vat
+	}));
+}
+function negated(items) {
+	return items.map((item) => ({
+		...item,
+		quantity: -Math.abs(item.quantity ?? 1)
+	}));
+}
+const REFUND_ITEMS_HINT = "A refundItems a visszatérített tételeket pozitív bruttó egységárral (grossUnitPrice) adja vissza; a kassza fordítja negatívba.";
+function assertRefundItems(items, refundId) {
+	for (const item of items) {
+		const price = item.grossUnitPrice;
+		const quantity = item.quantity ?? 1;
+		if (typeof price !== "number" || !Number.isFinite(price) || price <= 0) throw validation$1(`A refundItems „${item.name}” tételének nincs pozitív bruttó egységára (grossUnitPrice) a(z) ${refundId} visszatérítésnél.`, REFUND_ITEMS_HINT);
+		if (!Number.isFinite(quantity) || quantity === 0) throw validation$1(`A refundItems „${item.name}” tételének mennyisége érvénytelen (${quantity}) a(z) ${refundId} visszatérítésnél.`, REFUND_ITEMS_HINT);
+	}
+}
+function grossOf(items) {
+	return roundMoney(items.reduce((sum, item) => sum + Math.abs(item.quantity ?? 1) * (item.grossUnitPrice ?? 0), 0), 2);
+}
+async function correctionItems(refund, details, items, options) {
+	const custom = await options.refundItems?.({
+		refund,
+		invoiceNumber: details.header.number,
+		items
+	});
+	if (custom && custom.length > 0) {
+		assertRefundItems(custom, refund.id);
+		const gross = grossOf(custom);
+		if (!(Math.abs(gross - refund.amount.value) <= AMOUNT_TOLERANCE$1)) throw validation$1(`A refundItems tételeinek bruttó összege (${gross}) eltér a(z) ${refund.id} visszatérítés összegétől (${refund.amount.value}).`, REFUND_ITEMS_HINT);
+		return negated(custom);
+	}
+	return allocationItems(allocateRefund(items, refund.amount.value, {
+		decimals: decimalsFor(details.header.currency),
+		refundedBefore: refund.refundedBefore
+	}));
+}
+async function issueCorrection(api, payment, orderNumber, details, refund, items, options) {
+	const buyer = options.buyer ?? buyerOf(details);
+	if (!buyer) throw validation$1(`A(z) ${details.header.number} számla vevőjének címe nem olvasható ki, így a helyesbítő számla nem állítható ki.`, "Add meg a vevőt a buyer opcióban.");
+	const externalId = await correctionExternalId(orderNumber, refund.id);
+	const header = details.header;
+	const foreign = !isHuf(header.currency);
+	const extra = options.invoice ?? {};
+	const invoice = await api.invoices.createOnce({
+		...extra,
+		type: "corrective",
+		correctedInvoiceNumber: header.number,
+		paid: true,
+		paymentMethod: extra.paymentMethod ?? header.paymentMethod ?? payment.method,
+		currency: header.currency,
+		exchangeRate: foreign ? header.exchangeRate : void 0,
+		exchangeBank: foreign ? header.exchangeBank : void 0,
+		orderNumber,
+		externalId,
+		buyer,
+		items,
+		comment: extra.comment ?? `Részleges visszatérítés (${payment.provider}: ${refund.id}).`
+	}, {
+		signal: options.signal,
+		recoveryDelayMs: options.recoveryDelayMs,
+		matchOrderNumber: false
+	});
+	return {
+		refundId: refund.id,
+		externalId,
+		number: invoice.number,
+		created: invoice.created,
+		grossTotal: -refund.amount.value,
+		invoice
+	};
+}
+function mixedVatReason(rates) {
+	return `Az eredeti számlán több áfakulcs van (${[...rates].join(", ")}), ezért a kassza nem tudja, melyik tétel került visszatérítésre. Add meg a refundItems opciót, vagy ha arányos szétosztás a helyes (például százalékos kedvezmény), a partialRefund: 'proportional' beállítást.`;
+}
+async function correctInvoice(api, payment, orderNumber, details, refunds, options) {
+	const header = details.header;
+	if (header.type === "reversal" || header.reversed === true) return skipped$1(orderNumber, `A(z) ${header.number} számlát már sztornózták, ezért nem készül helyesbítő számla.`);
+	const items = refundableItems(details);
+	if (!items) throw validation$1(`A(z) ${header.number} számla tételei nem olvashatók ki egyértelműen (áfakulcs vagy negatív tétel), így a helyesbítés nem számolható.`, "Állítsd ki a helyesbítő számlát kézzel.");
+	assertRefunds(refunds, header.currency, header.number);
+	const rates = new Set(items.map((item) => String(item.vat)));
+	const mode = options.partialRefund ?? "auto";
+	if (rates.size > 1 && mode === "auto" && !options.refundItems) return proposal(orderNumber, "invoice", header.number, items, refunds, header.currency, mixedVatReason(rates));
+	const corrections = [];
+	for (const refund of refunds) {
+		const correction = await issueCorrection(api, payment, orderNumber, details, refund, await correctionItems(refund, details, items, options), options);
+		corrections.push(correction);
+	}
+	return {
+		kind: "correction",
+		orderNumber,
+		correctedNumber: header.number,
+		created: corrections.some((correction) => correction.created),
+		corrections
+	};
+}
+const RECEIPT_PROPOSAL_REASON = "Nyugtánál a részleges visszatérítés jogi menete nem egyértelmű (sztornó és új nyugta a megmaradó tételekről), ezért a kassza nem állít ki automatikusan bizonylatot. A javasolt tételbontást egyeztesd a könyvelőddel.";
+async function issueForPartialRefund(api, payment, orderNumber, options) {
+	if (options.partialRefund === "skip") return skipped$1(orderNumber, "Részleges visszatérítés: a partialRefund: skip beállítás miatt nem készül bizonylat.");
+	const refunds = payment.refunds ?? [];
+	if (refunds.length === 0) return skipped$1(orderNumber, `Részleges visszatérítés: a(z) ${payment.provider} esemény nem adta át tételesen a visszatérítéseket (azonosító és összeg), ezért a kassza nem tud idempotens helyesbítést kiállítani. Állítsd ki kézzel, vagy kapcsold be a szolgáltató részletes lekérdezését.`);
+	const find = (externalId) => api.invoices.find({ externalId }, { includePdf: false }, { signal: options.signal });
+	const invoice = await find(orderNumber);
+	if (invoice) return correctInvoice(api, payment, orderNumber, invoice, refunds, options);
+	const receipt = await api.receipts.find({
+		orderNumber,
+		downloadPdf: false
+	}, { signal: options.signal });
+	if (!receipt) return skipped$1(orderNumber, `A(z) ${payment.provider} részleges visszatérítéshez (${payment.id}) nem található kiállított bizonylat.`);
+	const original = receipt.type === "reversal" ? receipt.reversedReceiptNumber ?? receipt.number : receipt.number;
+	if (receipt.type === "reversal" || receipt.isReversed) {
+		const converted = await find(conversionExternalId(original));
+		if (converted) return correctInvoice(api, payment, orderNumber, converted, refunds, options);
+		return skipped$1(orderNumber, `A(z) ${original} nyugtát már sztornózták.`);
+	}
+	assertRefunds(refunds, receipt.currency, receipt.number);
+	return proposal(orderNumber, "receipt", receipt.number, receiptItems(receipt), refunds, receipt.currency, RECEIPT_PROPOSAL_REASON);
+}
+//#endregion
+//#region src/payments/issue.ts
+const AMOUNT_TOLERANCE = .005;
+const DEFAULT_ITEM_NAME = "Termék vagy szolgáltatás";
+const DEFAULT_CURRENCY = "HUF";
+const DEFAULT_EXCHANGE_BANK = "MNB";
+const INVOICE_REVERSAL_SUFFIX = "/SS";
+const RECEIPT_REVERSAL_SUFFIX = "/SN";
+function validation(message, hint) {
+	return new SzamlazzError(message, {
+		category: "validation",
+		hint
+	});
+}
+function skipped(orderNumber, reason) {
+	return {
+		kind: "skipped",
+		orderNumber,
+		reason
+	};
+}
+function paymentOrderNumber(payment) {
+	return `${payment.provider.toUpperCase()}-${payment.id}`;
+}
+let countryNames;
+function regionName(code) {
+	if (countryNames === void 0) try {
+		countryNames = new Intl.DisplayNames(["hu"], { type: "region" });
+	} catch {
+		countryNames = null;
+	}
+	try {
+		return countryNames?.of(code);
+	} catch {
+		return;
+	}
+}
+function countryName(code) {
+	const value = code?.trim();
+	if (!value) return void 0;
+	if (/^[A-Za-z]{2}$/.test(value)) {
+		if (value.toUpperCase() === "HU") return void 0;
+		return regionName(value.toUpperCase()) ?? value;
+	}
+	return value;
+}
+function buyerFromCustomer(customer) {
+	const address = customer?.address;
+	const name = customer?.name?.trim();
+	const zip = address?.zip?.trim();
+	const city = address?.city?.trim();
+	const street = [address?.line1, address?.line2].map((line) => line?.trim()).filter((line) => Boolean(line)).join(", ");
+	if (!name || !zip || !city || !street) return void 0;
+	return {
+		name,
+		zip,
+		city,
+		address: street,
+		country: countryName(address?.country),
+		email: customer?.email?.trim() || void 0,
+		taxNumber: customer?.taxNumber?.trim() || void 0,
+		euTaxNumber: customer?.euTaxNumber?.trim() || void 0
+	};
+}
+function vatOf(item, options) {
+	if (options.vatFor) return options.vatFor(item);
+	if (item.vatPercent !== void 0) {
+		if (isVatRate(item.vatPercent)) return item.vatPercent;
+		throw validation(`A(z) „${item.name}” tétel áfakulcsa (${item.vatPercent}%) nem ismert áfakulcs.`, "Add meg a vatFor opciót a helyes áfakulcs kiválasztásához.");
+	}
+	if (options.vat !== void 0) return options.vat;
+	throw validation(`A(z) „${item.name}” tételhez nincs áfakulcs.`, "Add meg az alapértelmezett áfakulcsot (vat), vagy tételenként (vatFor).");
+}
+function itemsOf(payment, options) {
+	if (options.items && options.items.length > 0) return [...options.items];
+	if (payment.items && payment.items.length > 0) return payment.items.map((item) => {
+		if (!(item.quantity > 0)) throw validation(`A(z) „${item.name}” tétel mennyisége nem pozitív.`);
+		return {
+			name: item.name,
+			quantity: item.quantity,
+			unit: item.unit,
+			identifier: item.sku,
+			grossUnitPrice: item.totalGross / item.quantity,
+			vat: vatOf(item, options)
+		};
+	});
+	if (payment.amount) {
+		const name = options.fallbackItemName?.trim() || DEFAULT_ITEM_NAME;
+		const fallback = {
+			name,
+			quantity: 1,
+			totalGross: payment.amount.value
+		};
+		return [{
+			name,
+			quantity: 1,
+			grossUnitPrice: payment.amount.value,
+			vat: vatOf(fallback, options)
+		}];
+	}
+	throw validation(`A(z) ${payment.provider} fizetésből (${payment.id}) sem összeg, sem tétel nem olvasható ki.`, "Add meg a tételeket az items opcióban (például a saját rendelésedből).");
+}
+function currencyOf(payment, options) {
+	const paid = payment.amount?.currency.trim().toUpperCase();
+	const configured = options.currency?.trim().toUpperCase();
+	if (paid && configured && paid !== configured) throw validation(`A fizetés pénzneme (${paid}) eltér a megadott pénznemtől (${configured}).`, "A bizonylat pénzneme mindig a fizetésé; a currency opció csak akkor kell, ha a fizetésből nem olvasható ki.");
+	return paid || configured || DEFAULT_CURRENCY;
+}
+function documentGross(items, currency, kind) {
+	if (kind === "receipt") return roundMoney(calculateReceiptItems(items, currency).reduce((sum, item) => sum + item.amounts.grossAmount, 0), 2);
+	return roundMoney(items.reduce((sum, item) => sum + calculateInvoiceItem(item, currency).grossAmount, 0), 2);
+}
+function assertAmountMatches(payment, items, currency, kind, options) {
+	if (!payment.amount || options.allowAmountMismatch === true) return;
+	const gross = documentGross(items, currency, kind);
+	if (Math.abs(gross - payment.amount.value) > AMOUNT_TOLERANCE) throw validation(`A bizonylat tételeinek bruttó összege (${gross} ${currency}) eltér a kifizetett összegtől (${payment.amount.value} ${payment.amount.currency}).`, "Ellenőrizd a tételeket (szállítás, kedvezmény), vagy ha szándékos, add meg az allowAmountMismatch: true opciót.");
+}
+function decide(payment, buyer, gross, currency, options) {
+	if (options.document === "receipt" || options.document === "invoice") {
+		const rate = isHuf(currency) ? 1 : options.exchangeRate;
+		return {
+			type: options.document,
+			reasons: ["A bizonylat típusát a hívó adta meg."],
+			grossTotalHuf: rate === void 0 ? NaN : roundMoney(gross * rate, 2)
+		};
+	}
+	const decision = chooseDocument({
+		grossTotal: gross,
+		currency,
+		exchangeRate: options.exchangeRate,
+		buyer: {
+			taxNumber: buyer?.taxNumber ?? payment.customer?.taxNumber,
+			euTaxNumber: buyer?.euTaxNumber ?? payment.customer?.euTaxNumber,
+			isBusiness: options.buyerIsBusiness ?? payment.customer?.isBusiness
+		},
+		paidByFulfillment: true,
+		invoiceRequested: options.invoiceRequested,
+		cashRegisterRequired: options.cashRegisterRequired
+	});
+	if (decision.type === "cash-register") throw validation(decision.reasons.join(" "));
+	return decision;
+}
+function onceOptions(options) {
+	return {
+		signal: options.signal,
+		recoveryDelayMs: options.recoveryDelayMs
+	};
+}
+async function issueReceipt(api, payment, orderNumber, items, currency, decision, options) {
+	const extra = options.receipt ?? {};
+	const foreign = !isHuf(currency);
+	const result = await api.receipts.createOnce({
+		...extra,
+		paymentMethod: extra.paymentMethod ?? payment.method,
+		currency,
+		exchangeRate: foreign ? options.exchangeRate : void 0,
+		exchangeBank: foreign ? options.exchangeBank ?? DEFAULT_EXCHANGE_BANK : void 0,
+		orderNumber,
+		callId: orderNumber,
+		items
+	}, onceOptions(options));
+	if (result.receipt.type === "reversal") return skipped(orderNumber, `A rendeléshez tartozó nyugtát már sztornózták (sztornó: ${result.receipt.number}), ezért nem készül új nyugta.`);
+	return {
+		kind: "receipt",
+		orderNumber,
+		number: result.receipt.number,
+		created: result.created,
+		receipt: result.receipt,
+		decision
+	};
+}
+async function issueInvoice(api, payment, orderNumber, items, currency, buyer, decision, options) {
+	if (!buyer) throw validation("Számlához a vevő neve és teljes címe kell, ezt a fizetésből nem lehetett kiolvasni.", "Add meg a vevőt a buyer opcióban.");
+	const extra = options.invoice ?? {};
+	const foreign = !isHuf(currency);
+	const invoice = await api.invoices.createOnce({
+		...extra,
+		paid: true,
+		paymentMethod: extra.paymentMethod ?? payment.method,
+		currency,
+		exchangeRate: foreign ? options.exchangeRate : void 0,
+		exchangeBank: foreign ? options.exchangeBank : void 0,
+		externalId: orderNumber,
+		orderNumber,
+		buyer,
+		items
+	}, onceOptions(options));
+	return {
+		kind: "invoice",
+		orderNumber,
+		number: invoice.number,
+		created: invoice.created,
+		invoice,
+		decision
+	};
+}
+async function reverseInvoiceOnce(api, orderNumber, invoiceNumber, options) {
+	const externalId = `${orderNumber}${INVOICE_REVERSAL_SUFFIX}`;
+	const lookup = () => api.invoices.find({ externalId }, { includePdf: false }, { signal: options.signal });
+	const base = {
+		kind: "reversal",
+		orderNumber,
+		document: "invoice",
+		reversedNumber: invoiceNumber
+	};
+	const existing = await lookup();
+	if (existing) return {
+		...base,
+		number: existing.header.number,
+		created: false
+	};
+	try {
+		const reversed = await api.invoices.reverse({
+			invoiceNumber,
+			externalId,
+			downloadPdf: false
+		}, { signal: options.signal });
+		return {
+			...base,
+			number: reversed.number,
+			created: true
+		};
+	} catch (error) {
+		if (!isUncertainOutcome(error)) throw error;
+		const delay = resolveRecoveryDelay(options.recoveryDelayMs);
+		const recovered = await recoverAfterFailure(lookup, delay, options.signal);
+		if (!recovered) throw error;
+		return {
+			...base,
+			number: recovered.header.number,
+			created: error.category !== "duplicate"
+		};
+	}
+}
+async function reverseConvertedInvoice(api, orderNumber, receiptNumber, options) {
+	const converted = await api.invoices.find({ externalId: conversionExternalId(receiptNumber) }, { includePdf: false }, { signal: options.signal });
+	if (!converted || converted.header.type === "reversal") return void 0;
+	return reverseInvoiceOnce(api, orderNumber, converted.header.number, options);
+}
+function receiptReversal(orderNumber, reversedNumber, number, created) {
+	return {
+		kind: "reversal",
+		orderNumber,
+		document: "receipt",
+		reversedNumber,
+		number,
+		created
+	};
+}
+function isReversedReceipt(receipt) {
+	return receipt.type === "reversal" || receipt.isReversed;
+}
+async function reverseReceiptForRefund(api, payment, orderNumber, options) {
+	const lookup = () => api.receipts.find({
+		orderNumber,
+		downloadPdf: false
+	}, { signal: options.signal });
+	const receipt = await lookup();
+	if (!receipt) return skipped(orderNumber, `A(z) ${payment.provider} visszatérítéshez (${payment.id}) nem található kiállított bizonylat.`);
+	if (isReversedReceipt(receipt)) {
+		const originalNumber = receipt.type === "reversal" ? receipt.reversedReceiptNumber ?? receipt.number : receipt.number;
+		const converted = await reverseConvertedInvoice(api, orderNumber, originalNumber, options);
+		if (converted) return converted;
+		return receiptReversal(orderNumber, originalNumber, receipt.type === "reversal" ? receipt.number : void 0, false);
+	}
+	try {
+		const reversal = await api.receipts.reverse({
+			receiptNumber: receipt.number,
+			callId: `${orderNumber}${RECEIPT_REVERSAL_SUFFIX}`,
+			downloadPdf: false
+		}, { signal: options.signal });
+		return receiptReversal(orderNumber, receipt.number, reversal.number, true);
+	} catch (error) {
+		if (!isUncertainOutcome(error)) throw error;
+		const delay = resolveRecoveryDelay(options.recoveryDelayMs);
+		const reversedLookup = async () => {
+			const current = await lookup();
+			return current && isReversedReceipt(current) ? current : null;
+		};
+		const recovered = await recoverAfterFailure(reversedLookup, delay, options.signal);
+		const created = error.category !== "duplicate";
+		if (recovered) {
+			const number = recovered.type === "reversal" ? recovered.number : void 0;
+			return receiptReversal(orderNumber, receipt.number, number, created);
+		}
+		if (!created) return receiptReversal(orderNumber, receipt.number, void 0, false);
+		throw error;
+	}
+}
+async function reverseForRefund(api, payment, orderNumber, options) {
+	const invoice = await api.invoices.find({ externalId: orderNumber }, { includePdf: false }, { signal: options.signal });
+	if (invoice && invoice.header.type !== "reversal") return reverseInvoiceOnce(api, orderNumber, invoice.header.number, options);
+	return reverseReceiptForRefund(api, payment, orderNumber, options);
+}
+function assertPaidAmount(payment) {
+	const value = payment.amount?.value;
+	if (value !== void 0 && (!Number.isFinite(value) || value < 0)) throw validation(`A(z) ${payment.provider} fizetés összege érvénytelen: ${value}`);
+}
+async function issueForPayment(api, payment, options = {}) {
+	resolveRecoveryDelay(options.recoveryDelayMs);
+	const orderNumber = options.orderNumber?.trim() || paymentOrderNumber(payment);
+	if (payment.kind === "refunded") return reverseForRefund(api, payment, orderNumber, options);
+	if (payment.kind === "partially-refunded") return issueForPartialRefund(api, payment, orderNumber, options);
+	if (payment.kind !== "paid") return skipped(orderNumber, `A fizetés állapota (${payment.kind}) nem sikeres fizetés, ezért nem készül bizonylat.`);
+	assertPaidAmount(payment);
+	if (payment.amount?.value === 0) return skipped(orderNumber, "A fizetett összeg 0, ezért nem készül bizonylat.");
+	const currency = currencyOf(payment, options);
+	const items = itemsOf(payment, options);
+	const buyer = options.buyer ?? buyerFromCustomer(payment.customer);
+	const decision = decide(payment, buyer, payment.amount?.value ?? documentGross(items, currency, "invoice"), currency, options);
+	const kind = decision.type === "receipt" ? "receipt" : "invoice";
+	assertAmountMatches(payment, items, currency, kind, options);
+	if (kind === "receipt") return issueReceipt(api, payment, orderNumber, items, currency, decision, options);
+	return issueInvoice(api, payment, orderNumber, items, currency, buyer, decision, options);
+}
+//#endregion
+export { conversionExternalId as a, chooseDocument as c, DEFAULT_LOCK_TTL_SECONDS as d, DEFAULT_LOCK_WAIT_MS as f, correctionExternalId as i, createInvoiceOnce as l, guardOnce as m, issueForPayment as n, convertReceiptToInvoice as o, ONCE_LOCK_KEY_PREFIX as p, paymentOrderNumber as r, RECEIPT_MAX_GROSS_HUF as s, buyerFromCustomer as t, invoiceOnceExternalId as u };