kassza 0.12.0 → 0.14.0

package/dist/client-CLFvJCVW.cjs

@@ -0,0 +1,1452 @@
+const require_create_once = require("./create-once-9yxR_Er_.cjs");
+const require_errors = require("./errors-EE96_6D_.cjs");
+const require_binary = require("./binary-B89HM03_.cjs");
+const require_serialize = require("./serialize-CquIsxA-.cjs");
+const require_parse = require("./parse-DOA2XQ3e.cjs");
+const require_session = require("./session-DeM5vjvC.cjs");
+const require_warnings = require("./warnings-DeIw5RFj.cjs");
+const require_issue = require("./issue-Bin4tKD_.cjs");
+const require_vat = require("./vat-g35srbNG.cjs");
+const require_money = require("./money-K9j0wPit.cjs");
+const require_reference = require("./reference-BIdYMK0t.cjs");
+const require_get = require("./get-BdMTseh4.cjs");
+const require_create = require("./create-CvUvLUaT.cjs");
+//#region src/core/attempt-ledger.ts
+const ATTEMPT_LEDGER_TTL_SECONDS = 86400;
+const ATTEMPT_LEDGER_KEY_PREFIX = "szamlazz:attempts:";
+const COUNTED_CATEGORIES = /* @__PURE__ */ new Set([
+	"auth",
+	"account",
+	"validation",
+	"maintenance",
+	"rate_limit",
+	"network",
+	"timeout",
+	"unexpected_response",
+	"unknown"
+]);
+function countsAsFailedAttempt(error) {
+	return COUNTED_CATEGORIES.has(error.category);
+}
+const encoder = new TextEncoder();
+async function attemptLedgerKey(request) {
+	const attachments = (request.attachments ?? []).map((attachment) => `${attachment.filename}:${attachment.size}`).join("|");
+	const digest = await crypto.subtle.digest("SHA-256", encoder.encode(`${request.action}\n${request.xml}\n${attachments}`));
+	const hex = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0"));
+	return `${ATTEMPT_LEDGER_KEY_PREFIX}${hex.join("")}`;
+}
+function parseCount(value) {
+	if (value === void 0 || value === null) return 0;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : 0;
+}
+function createLocalCounter() {
+	const counts = /* @__PURE__ */ new Map();
+	const get = (key) => {
+		const entry = counts.get(key);
+		if (!entry) return 0;
+		if (entry.expiresAt <= Date.now()) {
+			counts.delete(key);
+			return 0;
+		}
+		return entry.count;
+	};
+	return {
+		get,
+		bump(key) {
+			const count = get(key) + 1;
+			counts.delete(key);
+			counts.set(key, {
+				count,
+				expiresAt: Date.now() + ATTEMPT_LEDGER_TTL_SECONDS * 1e3
+			});
+			if (counts.size > 1e3) {
+				const oldest = counts.keys().next().value;
+				if (oldest !== void 0) counts.delete(oldest);
+			}
+		},
+		clear(key) {
+			counts.delete(key);
+		}
+	};
+}
+function createAttemptLedger(store) {
+	const local = createLocalCounter();
+	const unpersisted = createLocalCounter();
+	return {
+		async failures(key) {
+			return parseCount(await store.get(key)) + unpersisted.get(key);
+		},
+		fallbackFailures(key) {
+			return local.get(key);
+		},
+		async recordFailure(key) {
+			local.bump(key);
+			try {
+				if (store.increment) {
+					await store.increment(key, ATTEMPT_LEDGER_TTL_SECONDS);
+					return;
+				}
+				const current = parseCount(await store.get(key));
+				await store.set(key, String(current + 1), ATTEMPT_LEDGER_TTL_SECONDS);
+			} catch (error) {
+				unpersisted.bump(key);
+				throw error;
+			}
+		},
+		async reset(key) {
+			local.clear(key);
+			unpersisted.clear(key);
+			await store.delete(key);
+		}
+	};
+}
+function attemptLimitError(action, key, failures) {
+	return new require_errors.SzamlazzError(`Ezt a kérést már ${failures} alkalommal sikertelenül küldtük el, ezért a kassza nem küldi el újra.`, {
+		category: "attempt_limit",
+		action,
+		details: { attemptKey: key },
+		hint: "A Számlázz.hu szabályai szerint öt sikertelen próbálkozás után emberi beavatkozás kell, különben kitiltás jöhet. Javítsd a hibát, majd a kassza.resetAttempts(error) hívással töröld a számlálót."
+	});
+}
+const DEFAULT_SAFE_ATTEMPTS = 3;
+const DEFAULT_RETRY_DELAY_MS = 1e3;
+const RETRY_JITTER = .2;
+function readEnv(name) {
+	const value = (globalThis.process?.env)?.[name]?.trim();
+	return value ? value : void 0;
+}
+function configurationError(message) {
+	return new require_errors.SzamlazzError(message, { category: "configuration" });
+}
+function resolveCredentials(options) {
+	const agentKey = options.agentKey?.trim() || (options.username ? void 0 : readEnv("SZAMLAZZ_AGENT_KEY"));
+	if (agentKey) {
+		if (agentKey !== agentKey.toLowerCase()) throw configurationError("Az Agent kulcs nagybetűt tartalmaz. A Számlázz.hu csak kisbetűs kulcsot fogad el, másold ki újra a kulcsot.");
+		return [require_serialize.el("szamlaagentkulcs", agentKey)];
+	}
+	if (options.username && options.password) return [require_serialize.el("felhasznalo", options.username), require_serialize.el("jelszo", options.password)];
+	throw configurationError("Hiányzik az Agent kulcs. Add meg az agentKey opciót, vagy állítsd be a SZAMLAZZ_AGENT_KEY környezeti változót.");
+}
+function toBlob(attachment) {
+	const type = attachment.contentType ?? "application/octet-stream";
+	if (attachment.content instanceof Blob) return attachment.content;
+	return new Blob([attachment.content], { type });
+}
+function buildFormData(request) {
+	const form = new FormData();
+	form.append(require_create_once.AGENT_ACTIONS[request.action], new Blob([request.xml], { type: "text/xml; charset=UTF-8" }), "request.xml");
+	request.attachments?.forEach((attachment, index) => {
+		form.append(`attachfile${index + 1}`, toBlob(attachment), attachment.filename);
+	});
+	return form;
+}
+function isAbortError(error) {
+	return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+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 });
+	});
+}
+function hookWarning(name, action, error) {
+	return {
+		kind: "hook",
+		message: `A(z) ${name} hook hibát dobott, a kassza figyelmen kívül hagyta.`,
+		error,
+		action,
+		operation: name
+	};
+}
+function callHook(hooks, name, event) {
+	const hook = hooks[name];
+	if (!hook) return;
+	try {
+		const result = hook(event);
+		if (result instanceof Promise) result.catch((error) => require_warnings.emitWarning(hooks.onWarning, hookWarning(name, event.action, error)));
+	} catch (error) {
+		require_warnings.emitWarning(hooks.onWarning, hookWarning(name, event.action, error));
+	}
+}
+function parseRetryAfter(value, now) {
+	if (value === null) return void 0;
+	const trimmed = value.trim();
+	if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+	const date = Date.parse(trimmed);
+	if (Number.isNaN(date)) return void 0;
+	return Math.max(0, date - now);
+}
+function retryDelay(baseMs, attempt, random = Math.random()) {
+	const backoff = baseMs * 2 ** (attempt - 1);
+	return Math.round(backoff * (.8 + 2 * RETRY_JITTER * random));
+}
+function resolveLedgerMode(value) {
+	if (value === void 0 || value === "fail-open" || value === "fail-closed") return value ?? "fail-open";
+	throw configurationError(`Az attemptLedgerMode értéke 'fail-open' vagy 'fail-closed' lehet, kapott: ${String(value)}`);
+}
+function storeUnavailableError(action, error) {
+	return new require_errors.SzamlazzError("A próbálkozás-napló tárolója nem érhető el, ezért a kassza nem küldte el a kérést.", {
+		category: "store_unavailable",
+		action,
+		cause: error,
+		hint: "Az attemptLedgerMode: 'fail-closed' beállítás miatt a kassza nem küld kérést, amíg a napló (például a Redis) nem elérhető. Állítsd helyre a tárolót, vagy válts 'fail-open' módra."
+	});
+}
+function clampAttempts(value) {
+	if (value === void 0) return DEFAULT_SAFE_ATTEMPTS;
+	if (!Number.isInteger(value) || value < 1) throw configurationError(`A maxAttempts értéke legalább 1 egész szám legyen, kapott: ${value}`);
+	return Math.min(value, 5);
+}
+function resolveCooldown(value) {
+	if (value === void 0) return 0;
+	if (!Number.isFinite(value) || value < 0) throw configurationError(`A maintenanceCooldownMs értéke nemnegatív szám legyen, kapott: ${value}`);
+	return value;
+}
+function attachmentSize(attachment) {
+	const { content } = attachment;
+	if (typeof content === "string") return new TextEncoder().encode(content).byteLength;
+	if (content instanceof Blob) return content.size;
+	return content.byteLength;
+}
+function maintenanceCooldownError(action, remainingMs) {
+	return new require_errors.SzamlazzError(`A Számlázz.hu karbantartás miatt nem érhető el, a kassza még ${Math.ceil(remainingMs / 1e3)} másodpercig nem küld kérést.`, {
+		category: "maintenance",
+		action,
+		hint: "A maintenanceCooldownMs beállítás miatt a kérés el sem indult. Válts tartalék folyamatra (például kézi nyugtatömbre), vagy próbáld később."
+	});
+}
+function createAgentContext(options = {}) {
+	const credentials = resolveCredentials(options);
+	const endpoint = options.endpoint ?? "https://www.szamlazz.hu/szamla/";
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	if (typeof fetchImpl !== "function") throw configurationError("Nem található fetch implementáció. Add meg a fetch opciót.");
+	const timeoutMs = options.timeoutMs ?? 6e4;
+	const safeAttempts = clampAttempts(options.maxAttempts);
+	const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+	const cookieStore = options.cookieStore === false ? void 0 : options.cookieStore ?? require_session.memoryCookieStore();
+	const sessionSecret = credentials.map((node) => String(node.content)).join("|");
+	let sessionKeyPromise;
+	const resolveSessionKey = () => {
+		sessionKeyPromise ??= require_session.sessionKeyFor(sessionSecret);
+		return sessionKeyPromise;
+	};
+	const hooks = options.hooks ?? {};
+	const warn = (warning) => require_warnings.emitWarning(hooks.onWarning, warning);
+	const ledger = options.attemptLedger ? createAttemptLedger(options.attemptLedger) : void 0;
+	const ledgerMode = resolveLedgerMode(options.attemptLedgerMode);
+	async function ignoreStoreFailure(operation, action, run) {
+		try {
+			return await run();
+		} catch (error) {
+			warn({
+				kind: "session",
+				message: `A session cookie tároló "${operation}" művelete sikertelen, a kérés session nélkül folytatódik.`,
+				error,
+				action,
+				operation
+			});
+			return;
+		}
+	}
+	const cooldownMs = resolveCooldown(options.maintenanceCooldownMs);
+	let blockedUntil = 0;
+	async function send(request) {
+		const cookie = cookieStore ? await ignoreStoreFailure("get", request.action, async () => cookieStore.get(await resolveSessionKey())) : void 0;
+		request.signal?.throwIfAborted();
+		const headers = new Headers({ Accept: "application/xml, application/pdf, text/plain, */*" });
+		if (cookie) headers.set("Cookie", cookie);
+		const timeoutSignal = AbortSignal.timeout(timeoutMs);
+		const signal = request.signal ? AbortSignal.any([request.signal, timeoutSignal]) : timeoutSignal;
+		let response;
+		let body;
+		try {
+			response = await fetchImpl(endpoint, {
+				method: "POST",
+				headers,
+				body: buildFormData(request),
+				signal
+			});
+			body = new Uint8Array(await response.arrayBuffer());
+		} catch (error) {
+			if (request.signal?.aborted) throw request.signal.reason;
+			if (timeoutSignal.aborted || isAbortError(error)) throw new require_errors.SzamlazzError(`A Számlázz.hu nem válaszolt ${timeoutMs} ms alatt.`, {
+				category: "timeout",
+				action: request.action,
+				cause: error
+			});
+			throw new require_errors.SzamlazzError("Hálózati hiba a Számlázz.hu elérésekor.", {
+				category: "network",
+				action: request.action,
+				cause: error
+			});
+		}
+		if (cookieStore) {
+			const merged = require_session.mergeSetCookies(cookie, response.headers);
+			if (merged) await ignoreStoreFailure("set", request.action, async () => cookieStore.set(await resolveSessionKey(), merged, require_session.SESSION_TTL_SECONDS));
+		}
+		return {
+			response: require_parse.createAgentResponse(request.action, response.status, response.headers, body),
+			sessionReused: Boolean(cookie)
+		};
+	}
+	async function resetSession() {
+		if (cookieStore) await ignoreStoreFailure("delete", void 0, async () => cookieStore.delete(await resolveSessionKey()));
+	}
+	async function resetAttempts(key) {
+		if (ledger) await ledger.reset(key);
+	}
+	async function ledgerKeyFor(request) {
+		if (!ledger) return void 0;
+		return attemptLedgerKey({
+			action: request.action,
+			xml: request.xml,
+			attachments: (request.attachments ?? []).map((attachment) => ({
+				filename: attachment.filename,
+				size: attachmentSize(attachment)
+			}))
+		});
+	}
+	function ledgerWarning(operation, action, error) {
+		warn({
+			kind: "ledger",
+			message: `A próbálkozás-napló tárolójának "${operation}" művelete sikertelen. A kassza a folyamaton belüli számlálót használja, a folyamatok közötti védelem most nem él.`,
+			error,
+			action,
+			operation
+		});
+	}
+	async function readFailures(action, key) {
+		if (!ledger || key === void 0) return 0;
+		try {
+			return await ledger.failures(key);
+		} catch (error) {
+			if (ledgerMode === "fail-closed") throw storeUnavailableError(action, error);
+			ledgerWarning("get", action, error);
+			return ledger.fallbackFailures(key);
+		}
+	}
+	async function recordFailure(action, key) {
+		if (!ledger || key === void 0) return;
+		try {
+			await ledger.recordFailure(key);
+		} catch (error) {
+			ledgerWarning("increment", action, error);
+		}
+	}
+	async function clearFailures(action, key) {
+		if (!ledger || key === void 0) return;
+		try {
+			await ledger.reset(key);
+		} catch (error) {
+			ledgerWarning("delete", action, error);
+		}
+	}
+	function assertNoCooldown(action) {
+		const remainingMs = blockedUntil - Date.now();
+		if (remainingMs > 0) throw maintenanceCooldownError(action, remainingMs);
+	}
+	async function execute(request, parse) {
+		const maxAttempts = request.safeToRetry ? safeAttempts : 1;
+		const ledgerKey = await ledgerKeyFor(request);
+		const requestId = crypto.randomUUID();
+		for (let attempt = 1;; attempt++) {
+			assertNoCooldown(request.action);
+			const failures = await readFailures(request.action, ledgerKey);
+			if (ledgerKey !== void 0 && failures >= 5) throw attemptLimitError(request.action, ledgerKey, failures);
+			const startedAt = Date.now();
+			let retryAfterMs;
+			const base = {
+				action: request.action,
+				attempt,
+				requestId
+			};
+			callHook(hooks, "onRequest", base);
+			try {
+				const { response, sessionReused } = await send(request);
+				retryAfterMs = parseRetryAfter(response.headers.get("retry-after"), Date.now());
+				callHook(hooks, "onResponse", {
+					...base,
+					status: response.status,
+					durationMs: Date.now() - startedAt,
+					responseBytes: response.body.byteLength,
+					sessionReused
+				});
+				const result = await parse(response);
+				if (failures > 0) await clearFailures(request.action, ledgerKey);
+				callHook(hooks, "onComplete", {
+					...base,
+					outcome: "success",
+					durationMs: Date.now() - startedAt,
+					willRetry: false
+				});
+				return result;
+			} catch (error) {
+				if (!(error instanceof require_errors.SzamlazzError)) {
+					callHook(hooks, "onComplete", {
+						...base,
+						outcome: "error",
+						durationMs: Date.now() - startedAt,
+						willRetry: false
+					});
+					throw error;
+				}
+				if (countsAsFailedAttempt(error)) await recordFailure(request.action, ledgerKey);
+				if (error.category === "maintenance" && cooldownMs > 0) blockedUntil = Date.now() + cooldownMs;
+				const willRetry = error.retryable && attempt < maxAttempts && !(error.category === "maintenance" && cooldownMs > 0) && (retryAfterMs === void 0 || retryAfterMs <= 6e4);
+				callHook(hooks, "onError", {
+					...base,
+					error,
+					willRetry
+				});
+				callHook(hooks, "onComplete", {
+					...base,
+					outcome: "error",
+					durationMs: Date.now() - startedAt,
+					error,
+					willRetry
+				});
+				if (error.category === "auth") await resetSession();
+				if (!willRetry) throw error;
+				await sleep(Math.max(retryDelay(retryDelayMs, attempt), retryAfterMs ?? 0), request.signal);
+			}
+		}
+	}
+	return {
+		credentials,
+		warn,
+		execute,
+		resetSession,
+		resetAttempts
+	};
+}
+//#endregion
+//#region src/invoices/create-response.ts
+function readRawResponse(response) {
+	require_parse.throwIfAnyError(response);
+	const headers = require_parse.readDocumentHeaders(response.headers);
+	const fromHeaders = {
+		number: headers.number,
+		netTotal: headers.netTotal,
+		grossTotal: headers.grossTotal,
+		outstanding: void 0,
+		buyerAccountUrl: headers.buyerAccountUrl,
+		pdf: void 0
+	};
+	if (response.isPdf) return {
+		...fromHeaders,
+		pdf: response.body
+	};
+	if (require_parse.looksLikeXml(response)) {
+		const root = require_parse.parseResponseXml(response);
+		require_parse.throwIfXmlFailure(root, response);
+		const pdfBase64 = require_serialize.childText(root, "pdf");
+		return {
+			number: require_serialize.childText(root, "szamlaszam") ?? headers.number,
+			netTotal: require_serialize.childNumber(root, "szamlanetto") ?? headers.netTotal,
+			grossTotal: require_serialize.childNumber(root, "szamlabrutto") ?? headers.grossTotal,
+			outstanding: require_serialize.childNumber(root, "kintlevoseg"),
+			buyerAccountUrl: require_serialize.childText(root, "vevoifiokurl") ?? headers.buyerAccountUrl,
+			pdf: pdfBase64 === void 0 ? void 0 : require_binary.base64ToBytes(pdfBase64)
+		};
+	}
+	const done = require_parse.parseDoneText(response.text());
+	if (done) return {
+		...fromHeaders,
+		number: done.number ?? headers.number
+	};
+	if (headers.number !== void 0) return fromHeaders;
+	throw require_parse.unexpectedResponse(response, "Számlaszámot vagy PDF-et vártunk.");
+}
+function totalsFor(raw, items) {
+	if (raw.netTotal !== void 0 && raw.grossTotal !== void 0) return {
+		netTotal: raw.netTotal,
+		grossTotal: raw.grossTotal
+	};
+	const computed = require_money.summarizeItems(items);
+	return {
+		netTotal: raw.netTotal ?? computed.netAmount,
+		grossTotal: raw.grossTotal ?? computed.grossAmount
+	};
+}
+function parseCreateInvoiceResponse(response, items = []) {
+	const raw = readRawResponse(response);
+	if (raw.number === void 0) throw require_parse.unexpectedResponse(response, "A sikeres válaszból hiányzik a számlaszám.");
+	return {
+		number: raw.number,
+		...totalsFor(raw, items),
+		outstanding: raw.outstanding,
+		buyerAccountUrl: raw.buyerAccountUrl,
+		pdf: raw.pdf,
+		items
+	};
+}
+function parseInvoicePreviewResponse(response, items = []) {
+	const raw = readRawResponse(response);
+	if (raw.pdf === void 0) throw require_parse.unexpectedResponse(response, "Az előnézeti válaszból hiányzik a PDF.");
+	return {
+		pdf: raw.pdf,
+		...totalsFor(raw, items),
+		items
+	};
+}
+//#endregion
+//#region src/invoices/create-xml.ts
+const INVOICE_XML_NAMESPACE = "http://www.szamlazz.hu/xmlszamla";
+const INVOICE_XML_SCHEMA_LOCATION = "https://www.szamlazz.hu/szamla/docs/xsds/agent/xmlszamla.xsd";
+const RESPONSE_VERSION_XML = 2;
+function textEl(name, value) {
+	return require_serialize.optionalEl(name, require_create_once.presentText(value));
+}
+function settingsNode(credentials, invoice, preview) {
+	return require_serialize.el("beallitasok", [
+		...credentials,
+		require_serialize.el("eszamla", invoice.eInvoice),
+		require_serialize.el("szamlaLetoltes", preview || invoice.downloadPdf),
+		require_serialize.el("valaszVerzio", RESPONSE_VERSION_XML),
+		textEl("aggregator", invoice.aggregator),
+		require_serialize.optionalEl("guardian", invoice.guardian),
+		require_serialize.optionalEl("cikkazoninvoice", invoice.articleIdentifierInvoice),
+		textEl("szamlaKulsoAzon", invoice.input.externalId)
+	]);
+}
+function documentTypeNodes(invoice) {
+	const { input, type } = invoice;
+	return [
+		type === "advance" && require_serialize.el("elolegszamla", true),
+		type === "final" && require_serialize.el("vegszamla", true),
+		input.type === "final" && textEl("elolegSzamlaszam", input.advanceInvoiceNumber),
+		type === "corrective" && require_serialize.el("helyesbitoszamla", true),
+		input.type === "corrective" && textEl("helyesbitettSzamlaszam", input.correctedInvoiceNumber),
+		type === "proforma" && require_serialize.el("dijbekero", true),
+		type === "deliveryNote" && require_serialize.el("szallitolevel", true)
+	];
+}
+function headerNode(invoice, preview) {
+	const { input } = invoice;
+	return require_serialize.el("fejlec", [
+		require_serialize.el("keltDatum", invoice.issueDate),
+		require_serialize.el("teljesitesDatum", invoice.fulfillmentDate),
+		require_serialize.el("fizetesiHataridoDatum", invoice.dueDate),
+		require_serialize.el("fizmod", invoice.paymentMethod),
+		require_serialize.el("penznem", invoice.currency),
+		require_serialize.el("szamlaNyelve", invoice.language),
+		textEl("megjegyzes", input.comment),
+		textEl("arfolyamBank", invoice.exchangeBank),
+		require_serialize.optionalEl("arfolyam", invoice.exchangeRate),
+		textEl("rendelesSzam", input.orderNumber),
+		textEl("dijbekeroSzamlaszam", input.proformaNumber),
+		...documentTypeNodes(invoice),
+		textEl("logoExtra", invoice.logoExtra),
+		textEl("szamlaszamElotag", invoice.prefix),
+		require_serialize.optionalEl("fizetendoKorrekcio", input.paymentCorrection),
+		require_serialize.optionalEl("fizetve", input.paid),
+		require_serialize.optionalEl("arresAfa", input.marginVat),
+		require_serialize.optionalEl("eusAfa", invoice.euVat),
+		require_serialize.optionalEl("szamlaSablon", invoice.template),
+		preview && require_serialize.el("elonezetpdf", true),
+		require_serialize.optionalEl("simpleItems", invoice.simpleItems)
+	]);
+}
+function sellerNode(seller) {
+	return require_serialize.el("elado", [
+		textEl("bank", seller.bank),
+		textEl("bankszamlaszam", seller.bankAccount),
+		textEl("emailReplyto", seller.emailReplyTo),
+		textEl("emailTargy", seller.emailSubject),
+		textEl("emailSzoveg", seller.emailText),
+		textEl("alairoNeve", seller.signatoryName)
+	]);
+}
+function buyerLedgerNode(ledger) {
+	if (!ledger) return void 0;
+	return require_serialize.optionalEl("vevoFokonyv", [
+		require_serialize.optionalEl("konyvelesDatum", require_create_once.optionalAgentDate(ledger.bookingDate, "buyer.ledger.bookingDate")),
+		textEl("vevoAzonosito", ledger.buyerId),
+		textEl("vevoFokonyviSzam", ledger.ledgerAccount),
+		require_serialize.optionalEl("folyamatosTelj", ledger.continuousFulfillment),
+		require_serialize.optionalEl("elszDatumTol", require_create_once.optionalAgentDate(ledger.settlementPeriodStart, "buyer.ledger.settlementPeriodStart")),
+		require_serialize.optionalEl("elszDatumIg", require_create_once.optionalAgentDate(ledger.settlementPeriodEnd, "buyer.ledger.settlementPeriodEnd"))
+	]);
+}
+function buyerNode(buyer, sendEmail) {
+	const taxpayerType = buyer.taxpayerType;
+	return require_serialize.el("vevo", [
+		require_serialize.el("nev", buyer.name),
+		textEl("orszag", buyer.country),
+		require_serialize.el("irsz", buyer.zip),
+		require_serialize.el("telepules", buyer.city),
+		require_serialize.el("cim", buyer.address),
+		textEl("email", buyer.email),
+		require_serialize.el("sendEmail", sendEmail),
+		require_serialize.optionalEl("adoalany", taxpayerType === void 0 ? void 0 : require_create_once.TAXPAYER_TYPE_CODES[taxpayerType]),
+		textEl("adoszam", buyer.taxNumber),
+		textEl("csoportazonosito", buyer.groupTaxNumber),
+		textEl("adoszamEU", buyer.euTaxNumber),
+		textEl("postazasiNev", buyer.postal?.name),
+		textEl("postazasiOrszag", buyer.postal?.country),
+		textEl("postazasiIrsz", buyer.postal?.zip),
+		textEl("postazasiTelepules", buyer.postal?.city),
+		textEl("postazasiCim", buyer.postal?.address),
+		buyerLedgerNode(buyer.ledger),
+		textEl("azonosito", buyer.identifier),
+		textEl("alairoNeve", buyer.signatoryName),
+		textEl("telefonszam", buyer.phone),
+		textEl("megjegyzes", buyer.comment)
+	]);
+}
+function waybillNode(waybill) {
+	if (!waybill) return void 0;
+	const { transOFlex: tof, pickPackPoint: ppp, sprinter, mpl } = waybill;
+	return require_serialize.el("fuvarlevel", [
+		textEl("futarSzolgalat", waybill.courier),
+		textEl("vonalkod", waybill.barcode),
+		textEl("megjegyzes", waybill.comment),
+		tof && require_serialize.el("tof", [
+			textEl("azonosito", tof.id),
+			textEl("shipmentID", tof.shipmentId),
+			require_serialize.optionalEl("csomagszam", tof.packageCount),
+			textEl("countryCode", tof.countryCode),
+			textEl("zip", tof.zip),
+			textEl("service", tof.service)
+		]),
+		ppp && require_serialize.el("ppp", [textEl("vonalkodPrefix", ppp.barcodePrefix), textEl("vonalkodPostfix", ppp.barcodePostfix)]),
+		sprinter && require_serialize.el("sprinter", [
+			textEl("azonosito", sprinter.id),
+			textEl("feladokod", sprinter.senderCode),
+			textEl("iranykod", sprinter.directionCode),
+			require_serialize.optionalEl("csomagszam", sprinter.packageCount),
+			textEl("vonalkodPostfix", sprinter.barcodePostfix),
+			textEl("szallitasiIdo", sprinter.deliveryTime)
+		]),
+		mpl && require_serialize.el("mpl", [
+			require_serialize.el("vevokod", mpl.customerCode),
+			require_serialize.el("vonalkod", mpl.barcode),
+			require_serialize.el("tomeg", String(mpl.weight)),
+			textEl("kulonszolgaltatasok", mpl.services),
+			require_serialize.optionalEl("erteknyilvanitas", mpl.declaredValue)
+		])
+	]);
+}
+function itemLedgerNode(ledger, label) {
+	if (!ledger) return void 0;
+	return require_serialize.optionalEl("tetelFokonyv", [
+		textEl("gazdasagiEsem", ledger.economicEvent),
+		textEl("gazdasagiEsemAfa", ledger.vatEconomicEvent),
+		textEl("arbevetelFokonyviSzam", ledger.revenueLedgerAccount),
+		textEl("afaFokonyviSzam", ledger.vatLedgerAccount),
+		require_serialize.optionalEl("elszDatumTol", require_create_once.optionalAgentDate(ledger.settlementPeriodStart, `${label} settlementPeriodStart`)),
+		require_serialize.optionalEl("elszDatumIg", require_create_once.optionalAgentDate(ledger.settlementPeriodEnd, `${label} settlementPeriodEnd`))
+	]);
+}
+function itemNode(item, index) {
+	const { input, amounts } = item;
+	return require_serialize.el("tetel", [
+		require_serialize.el("megnevezes", input.name),
+		textEl("azonosito", input.identifier),
+		require_serialize.el("mennyiseg", amounts.quantity),
+		require_serialize.el("mennyisegiEgyseg", item.unit),
+		require_serialize.el("nettoEgysegar", amounts.netUnitPrice),
+		require_serialize.el("afakulcs", require_vat.formatVatRate(amounts.vat)),
+		require_serialize.optionalEl("arresAfaAlap", input.marginVatBase),
+		require_serialize.el("nettoErtek", amounts.netAmount),
+		require_serialize.el("afaErtek", amounts.vatAmount),
+		require_serialize.el("bruttoErtek", amounts.grossAmount),
+		textEl("megjegyzes", input.comment),
+		itemLedgerNode(input.ledger, `${index + 1}. tétel ledger`),
+		require_serialize.optionalEl("torloKod", input.dataDeletionCode)
+	]);
+}
+function renderInvoiceXml(credentials, invoice, options = {}) {
+	const preview = options.preview === true;
+	return require_serialize.buildXmlDocument({
+		root: "xmlszamla",
+		namespace: INVOICE_XML_NAMESPACE,
+		schemaLocation: INVOICE_XML_SCHEMA_LOCATION,
+		children: [
+			settingsNode(credentials, invoice, preview),
+			headerNode(invoice, preview),
+			sellerNode(invoice.seller),
+			buyerNode(invoice.input.buyer, invoice.sendEmail),
+			waybillNode(invoice.input.waybill),
+			require_serialize.el("tetelek", invoice.items.map(itemNode))
+		]
+	});
+}
+function buildCreateInvoiceXml(credentials, defaults, input, now = /* @__PURE__ */ new Date()) {
+	return renderInvoiceXml(credentials, require_create_once.resolveInvoice(defaults, input, now));
+}
+//#endregion
+//#region src/invoices/create.ts
+function buildRequest(ctx, invoice, preview, options) {
+	const xml = renderInvoiceXml(ctx.credentials, invoice, { preview });
+	const attachments = preview ? [] : invoice.attachments;
+	return {
+		action: "createInvoice",
+		xml,
+		signal: options.signal,
+		...attachments.length > 0 ? { attachments } : {}
+	};
+}
+function itemsOf(invoice) {
+	return invoice.items.map((item) => item.amounts);
+}
+async function createInvoice(ctx, defaults, input, options = {}) {
+	const invoice = require_create_once.resolveInvoice(defaults, input, /* @__PURE__ */ new Date());
+	const items = itemsOf(invoice);
+	return ctx.execute(buildRequest(ctx, invoice, false, options), (response) => parseCreateInvoiceResponse(response, items));
+}
+async function previewInvoice(ctx, defaults, input, options = {}) {
+	const invoice = require_create_once.resolveInvoice(defaults, input, /* @__PURE__ */ new Date());
+	const items = itemsOf(invoice);
+	return ctx.execute(buildRequest(ctx, invoice, true, options), (response) => parseInvoicePreviewResponse(response, items));
+}
+//#endregion
+//#region src/invoices/pdf.ts
+function buildInvoicePdfXml(credentials, reference) {
+	const resolved = require_reference.resolveInvoiceReference(reference);
+	return require_serialize.buildXmlDocument({
+		root: "xmlszamlapdf",
+		namespace: "http://www.szamlazz.hu/xmlszamlapdf",
+		schemaLocation: `${require_reference.AGENT_XSD_BASE_URL}agentpdf/xmlszamlapdf.xsd`,
+		children: [
+			...credentials,
+			require_serialize.optionalEl("szamlaszam", require_reference.referenceValue(resolved, "invoiceNumber")),
+			require_serialize.optionalEl("rendelesSzam", require_reference.referenceValue(resolved, "orderNumber")),
+			require_serialize.el("valaszVerzio", 2),
+			require_serialize.optionalEl("szamlaKulsoAzon", require_reference.referenceValue(resolved, "externalId"))
+		]
+	});
+}
+function parseInvoicePdfResponse(response) {
+	const { pdf, ...rest } = require_reference.parseInvoiceResult(response);
+	if (pdf === void 0 || pdf.length === 0) throw require_parse.unexpectedResponse(response, "A válasz nem tartalmaz PDF-et.");
+	return {
+		...rest,
+		pdf
+	};
+}
+async function getInvoicePdf(ctx, reference, options = {}) {
+	const xml = buildInvoicePdfXml(ctx.credentials, reference);
+	return ctx.execute({
+		action: "getInvoicePdf",
+		xml,
+		signal: options.signal,
+		safeToRetry: true
+	}, parseInvoicePdfResponse);
+}
+const RESPONSE_ROOTS = /* @__PURE__ */ new Set(["xmlszamladbkdelvalasz", "xmlszamlavalasz"]);
+const REFERENCE_HINT = "Add meg a díjbekérő számát szövegként, vagy pontosan egyet ezek közül: { proformaNumber }, { orderNumber }.";
+function resolveProformaReference(reference) {
+	if (typeof reference === "string") return { proformaNumber: require_reference.requireText(reference, `Üres díjbekérőszám. ${REFERENCE_HINT}`) };
+	if (typeof reference !== "object" || reference === null) throw require_reference.validationError(`Érvénytelen díjbekérő-hivatkozás. ${REFERENCE_HINT}`);
+	const record = reference;
+	const hasNumber = record.proformaNumber !== void 0;
+	if (hasNumber === (record.orderNumber !== void 0)) throw require_reference.validationError(`Érvénytelen díjbekérő-hivatkozás. ${REFERENCE_HINT}`);
+	return hasNumber ? { proformaNumber: require_reference.requireText(record.proformaNumber, `Üres proformaNumber. ${REFERENCE_HINT}`) } : { orderNumber: require_reference.requireText(record.orderNumber, `Üres orderNumber. ${REFERENCE_HINT}`) };
+}
+function buildDeleteProformaXml(credentials, reference) {
+	const resolved = resolveProformaReference(reference);
+	return require_serialize.buildXmlDocument({
+		root: "xmlszamladbkdel",
+		namespace: "http://www.szamlazz.hu/xmlszamladbkdel",
+		schemaLocation: "http://www.szamlazz.hu/docs/xsds/szamladbkdel/xmlszamladbkdel.xsd",
+		children: [require_serialize.el("beallitasok", [...credentials]), require_serialize.el("fejlec", [require_serialize.optionalEl("szamlaszam", resolved.proformaNumber), require_serialize.optionalEl("rendelesszam", resolved.orderNumber)])]
+	});
+}
+function withProformaCategory(error) {
+	if (!(error instanceof require_errors.SzamlazzError) || error.code !== 335) return error;
+	return new require_errors.SzamlazzError(error.message, {
+		category: "not_found",
+		code: error.code,
+		hint: "A díjbekérő nem létezik, vagy már törölték.",
+		action: error.action,
+		httpStatus: error.httpStatus,
+		rawResponse: error.rawResponse,
+		cause: error
+	});
+}
+function parseDeleteProformaResponse(response) {
+	try {
+		require_parse.throwIfHeaderError(response);
+		require_parse.throwIfTextError(response);
+		require_parse.throwIfHttpError(response);
+		const root = require_parse.parseResponseXml(response);
+		require_parse.throwIfXmlFailure(root, response);
+		if (!RESPONSE_ROOTS.has(root.name) || require_serialize.childText(root, "sikeres")?.toLowerCase() !== "true") throw require_parse.unexpectedResponse(response, "xmlszamladbkdelvalasz XML választ vártunk.");
+	} catch (error) {
+		throw withProformaCategory(error);
+	}
+}
+async function deleteProforma(ctx, reference, options = {}) {
+	const xml = buildDeleteProformaXml(ctx.credentials, reference);
+	await ctx.execute({
+		action: "deleteProforma",
+		xml,
+		signal: options.signal
+	}, parseDeleteProformaResponse);
+}
+const templates = new Set(require_create_once.INVOICE_TEMPLATES);
+function normalizeInput$2(input) {
+	return typeof input === "string" ? { invoiceNumber: input } : input;
+}
+function validateTemplate(template) {
+	if (template === void 0 || templates.has(template)) return template;
+	throw require_reference.validationError(`Ismeretlen számlasablon: ${String(template)}. Lehetséges értékek: ${require_create_once.INVOICE_TEMPLATES.join(", ")}.`);
+}
+function buildReverseInvoiceXml(credentials, input) {
+	const options = normalizeInput$2(input);
+	const invoiceNumber = require_reference.requireText(options.invoiceNumber, "Add meg a sztornózandó számla számát (invoiceNumber).");
+	const email = options.email;
+	const buyer = options.buyer;
+	return require_serialize.buildXmlDocument({
+		root: "xmlszamlast",
+		namespace: "http://www.szamlazz.hu/xmlszamlast",
+		schemaLocation: `${require_reference.AGENT_XSD_BASE_URL}agentst/xmlszamlast.xsd`,
+		children: [
+			require_serialize.el("beallitasok", [
+				...credentials,
+				require_serialize.el("eszamla", options.eInvoice ?? false),
+				require_serialize.el("szamlaLetoltes", options.downloadPdf ?? true),
+				require_serialize.el("valaszVerzio", 2),
+				require_serialize.optionalEl("szamlaKulsoAzon", require_reference.optionalText(options.externalId))
+			]),
+			require_serialize.el("fejlec", [
+				require_serialize.el("szamlaszam", invoiceNumber),
+				require_serialize.optionalEl("keltDatum", require_reference.optionalAgentDate(options.issueDate, "issueDate")),
+				require_serialize.optionalEl("teljesitesDatum", require_reference.optionalAgentDate(options.fulfillmentDate, "fulfillmentDate")),
+				require_serialize.optionalEl("megjegyzes", require_reference.optionalText(options.comment)),
+				require_serialize.el("tipus", "SS"),
+				require_serialize.optionalEl("szamlaSablon", validateTemplate(options.template))
+			]),
+			require_serialize.optionalEl("elado", [
+				require_serialize.optionalEl("emailReplyto", require_reference.optionalText(email?.replyTo)),
+				require_serialize.optionalEl("emailTargy", require_reference.optionalText(email?.subject)),
+				require_serialize.optionalEl("emailSzoveg", require_reference.optionalText(email?.text))
+			]),
+			require_serialize.optionalEl("vevo", [
+				require_serialize.optionalEl("email", require_reference.optionalText(buyer?.email)),
+				require_serialize.optionalEl("adoszam", require_reference.optionalText(buyer?.taxNumber)),
+				require_serialize.optionalEl("adoszamEU", require_reference.optionalText(buyer?.euTaxNumber))
+			])
+		]
+	});
+}
+function parseReverseInvoiceResponse(response, originalInvoiceNumber) {
+	const result = require_reference.parseInvoiceResult(response);
+	if (result.number === void 0) throw require_parse.unexpectedResponse(response, "A válaszban nincs sztornó számlaszám.");
+	if (originalInvoiceNumber !== void 0 && result.number === originalInvoiceNumber.trim()) throw new require_errors.SzamlazzError(`A(z) ${result.number} bizonylat nem lett sztornózva: a Számlázz.hu az eredeti bizonylatot adta vissza.`, {
+		category: "validation",
+		action: response.action,
+		httpStatus: response.status,
+		hint: "Díjbekérő és szállítólevél nem sztornózható. Díjbekérőt a deleteProforma függvénnyel törölhetsz."
+	});
+	return {
+		...result,
+		number: result.number
+	};
+}
+async function reverseInvoice(ctx, input, options = {}) {
+	const invoiceNumber = normalizeInput$2(input).invoiceNumber;
+	const xml = buildReverseInvoiceXml(ctx.credentials, input);
+	return ctx.execute({
+		action: "reverseInvoice",
+		xml,
+		signal: options.signal
+	}, (response) => parseReverseInvoiceResponse(response, invoiceNumber));
+}
+//#endregion
+//#region src/receipts/get.ts
+const GET_RECEIPT_NAMESPACE = "http://www.szamlazz.hu/xmlnyugtaget";
+function normalizeInput$1(input) {
+	return typeof input === "string" ? { receiptNumber: input } : input;
+}
+function resolveIdentifier(input) {
+	const receiptNumber = require_create.optionalText(input.receiptNumber);
+	const orderNumber = require_create.optionalText(input.orderNumber);
+	if (receiptNumber === void 0 && orderNumber === void 0) throw require_create.receiptValidationError("A nyugta lekérdezéséhez add meg a nyugtaszámot (receiptNumber) vagy a rendelésszámot (orderNumber).");
+	if (receiptNumber !== void 0 && orderNumber !== void 0) throw require_create.receiptValidationError("A nyugta lekérdezéséhez a nyugtaszám (receiptNumber) és a rendelésszám (orderNumber) közül csak az egyiket add meg.");
+	return {
+		receiptNumber,
+		orderNumber
+	};
+}
+function buildGetReceiptXml(credentials, input) {
+	const normalized = normalizeInput$1(input);
+	const { receiptNumber, orderNumber } = resolveIdentifier(normalized);
+	return require_serialize.buildXmlDocument({
+		root: "xmlnyugtaget",
+		namespace: GET_RECEIPT_NAMESPACE,
+		schemaLocation: `${require_create.RECEIPT_XSD_BASE_URL}nyugtaget/xmlnyugtaget.xsd`,
+		children: [require_serialize.el("beallitasok", [...credentials, require_serialize.el("pdfLetoltes", normalized.downloadPdf ?? true)]), require_serialize.el("fejlec", [
+			require_serialize.optionalEl("nyugtaszam", receiptNumber),
+			require_serialize.optionalEl("rendelesSzam", orderNumber),
+			require_serialize.optionalEl("hivasAzonosito", require_create.optionalText(normalized.callId)),
+			require_serialize.optionalEl("pdfSablon", require_create.validateTemplate(normalized.template))
+		])]
+	});
+}
+function getReceipt(ctx, input, options = {}) {
+	const xml = buildGetReceiptXml(ctx.credentials, input);
+	return ctx.execute({
+		action: "getReceipt",
+		xml,
+		signal: options.signal,
+		safeToRetry: true
+	}, require_parse.parseReceiptResponse);
+}
+//#endregion
+//#region src/receipts/reverse.ts
+const REVERSE_RECEIPT_NAMESPACE = "http://www.szamlazz.hu/xmlnyugtast";
+function normalizeInput(input) {
+	return typeof input === "string" ? { receiptNumber: input } : input;
+}
+function buildReverseReceiptXml(credentials, input) {
+	const normalized = normalizeInput(input);
+	return require_serialize.buildXmlDocument({
+		root: "xmlnyugtast",
+		namespace: REVERSE_RECEIPT_NAMESPACE,
+		schemaLocation: `${require_create.RECEIPT_XSD_BASE_URL}nyugtast/xmlnyugtast.xsd`,
+		children: [require_serialize.el("beallitasok", [...credentials, require_serialize.el("pdfLetoltes", normalized.downloadPdf ?? true)]), require_serialize.el("fejlec", [
+			require_serialize.el("nyugtaszam", require_create.requireReceiptNumber(normalized.receiptNumber)),
+			require_serialize.optionalEl("pdfSablon", require_create.validateTemplate(normalized.template)),
+			require_serialize.optionalEl("hivasAzonosito", require_create.optionalText(normalized.callId))
+		])]
+	});
+}
+function reverseReceipt(ctx, input, options = {}) {
+	const normalized = normalizeInput(input);
+	const xml = buildReverseReceiptXml(ctx.credentials, normalized);
+	return ctx.execute({
+		action: "reverseReceipt",
+		xml,
+		signal: options.signal,
+		safeToRetry: require_create.optionalText(normalized.callId) !== void 0
+	}, require_parse.parseReceiptResponse);
+}
+//#endregion
+//#region src/receipts/send.ts
+const SEND_RECEIPT_NAMESPACE = "http://www.szamlazz.hu/xmlnyugtasend";
+const EMAIL_PATTERN = /^[^\s@,;<>]+@[^\s@,;<>]+\.[^\s@,;<>]+$/;
+function isValidEmail(value) {
+	return EMAIL_PATTERN.test(value);
+}
+function assertEmail(value, field) {
+	if (!isValidEmail(value)) throw require_create.receiptValidationError(`Érvénytelen e-mail cím a(z) ${field} mezőben: ${value}`);
+	return value;
+}
+function normalizeEmails(emails) {
+	const list = (typeof emails === "string" ? [emails] : [...emails]).flatMap((entry) => entry.split(/[,;]/)).map((entry) => entry.trim()).filter((entry) => entry !== "");
+	if (list.length === 0) throw require_create.receiptValidationError("Adj meg legalább egy címzett e-mail címet (emails).");
+	return list.map((email) => assertEmail(email, "emails"));
+}
+function buildSendReceiptXml(credentials, input) {
+	const receiptNumber = require_create.requireReceiptNumber(input.receiptNumber);
+	const emails = normalizeEmails(input.emails);
+	const replyTo = require_create.optionalText(input.replyTo);
+	if (replyTo !== void 0) assertEmail(replyTo, "replyTo");
+	return require_serialize.buildXmlDocument({
+		root: "xmlnyugtasend",
+		namespace: SEND_RECEIPT_NAMESPACE,
+		schemaLocation: `${require_create.RECEIPT_XSD_BASE_URL}nyugtasend/xmlnyugtasend.xsd`,
+		children: [
+			require_serialize.el("beallitasok", credentials),
+			require_serialize.el("fejlec", [require_serialize.el("nyugtaszam", receiptNumber)]),
+			require_serialize.el("emailKuldes", [
+				require_serialize.el("email", emails.join(",")),
+				require_serialize.optionalEl("emailReplyto", replyTo),
+				require_serialize.el("emailTargy", require_create.optionalText(input.subject) ?? `Nyugta ${receiptNumber}`),
+				require_serialize.optionalEl("emailSzoveg", input.text?.trim() ? input.text : void 0)
+			])
+		]
+	});
+}
+function parseSendReceiptResponse(response) {
+	require_parse.throwIfHeaderError(response);
+	require_parse.throwIfTextError(response);
+	if (!require_parse.looksLikeXml(response)) {
+		require_parse.throwIfHttpError(response);
+		if (require_parse.parseDoneText(response.text())) return;
+		throw require_parse.unexpectedResponse(response, "XML választ vártunk a nyugta kiküldésére.");
+	}
+	const root = require_parse.parseResponseXml(response);
+	require_parse.throwIfXmlFailure(root, response);
+	if (require_serialize.childBoolean(root, "sikeres") !== true) {
+		require_parse.throwIfHttpError(response);
+		throw require_parse.unexpectedResponse(response, "A válasz nem jelez sikeres kiküldést.");
+	}
+}
+function sendReceipt(ctx, input, options = {}) {
+	const xml = buildSendReceiptXml(ctx.credentials, input);
+	return ctx.execute({
+		action: "sendReceipt",
+		xml,
+		signal: options.signal
+	}, parseSendReceiptResponse);
+}
+//#endregion
+//#region src/taxpayer/address.ts
+const ROMAN_NUMERAL = /^[IVX]{1,5}\.?$/;
+function isShouting(value) {
+	return value === value.toUpperCase() && value !== value.toLowerCase();
+}
+function capitalizeWord(word) {
+	if (ROMAN_NUMERAL.test(word)) return word;
+	return word.split("-").map((part) => part.toLowerCase().replace(/\p{L}/u, (letter) => letter.toUpperCase())).join("-");
+}
+function toReadableName(value) {
+	if (value === void 0 || !isShouting(value)) return value;
+	return value.split(" ").map(capitalizeWord).join(" ");
+}
+function toLowerIfShouting(value) {
+	return value !== void 0 && isShouting(value) ? value.toLowerCase() : value;
+}
+function withOrdinalDot(value) {
+	if (value === void 0) return void 0;
+	return /^\d+$/.test(value) ? `${value}.` : value;
+}
+function joinParts(parts) {
+	return parts.filter((part) => part !== void 0 && part !== "").join(" ");
+}
+function formatAddress(address) {
+	return [
+		joinParts([address.postalCode, address.city]),
+		joinParts([
+			address.street,
+			address.publicPlaceCategory,
+			withOrdinalDot(address.number),
+			address.building === void 0 ? void 0 : `${address.building} ép.`,
+			address.staircase === void 0 ? void 0 : `${withOrdinalDot(address.staircase)} lh.`,
+			address.floor === void 0 ? void 0 : `${withOrdinalDot(address.floor)} em.`,
+			address.door === void 0 ? void 0 : `${withOrdinalDot(address.door)} ajtó`
+		]),
+		address.lotNumber === void 0 ? void 0 : `hrsz. ${address.lotNumber}`,
+		address.countryCode === "" || address.countryCode === "HU" ? void 0 : address.countryCode
+	].filter((part) => part !== void 0 && part !== "").join(", ");
+}
+function readDetailedAddress(element) {
+	return {
+		countryCode: require_serialize.childText(element, "countryCode"),
+		region: require_serialize.childText(element, "region"),
+		postalCode: require_serialize.childText(element, "postalCode"),
+		city: require_serialize.childText(element, "city"),
+		streetName: require_serialize.childText(element, "streetName"),
+		publicPlaceCategory: require_serialize.childText(element, "publicPlaceCategory"),
+		number: require_serialize.childText(element, "number"),
+		building: require_serialize.childText(element, "building"),
+		staircase: require_serialize.childText(element, "staircase"),
+		floor: require_serialize.childText(element, "floor"),
+		door: require_serialize.childText(element, "door"),
+		lotNumber: require_serialize.childText(element, "lotNumber")
+	};
+}
+function parseTaxpayerAddress(item) {
+	const raw = readDetailedAddress(require_serialize.findChild(item, "taxpayerAddress"));
+	const address = {
+		type: require_serialize.childText(item, "taxpayerAddressType")?.toUpperCase() ?? "",
+		countryCode: raw.countryCode?.toUpperCase() ?? "",
+		region: toReadableName(raw.region),
+		postalCode: raw.postalCode ?? "",
+		city: toReadableName(raw.city) ?? "",
+		street: toReadableName(raw.streetName),
+		publicPlaceCategory: toLowerIfShouting(raw.publicPlaceCategory),
+		number: raw.number,
+		building: raw.building,
+		staircase: raw.staircase,
+		floor: raw.floor,
+		door: raw.door,
+		lotNumber: raw.lotNumber
+	};
+	return {
+		...address,
+		formatted: formatAddress(address),
+		raw
+	};
+}
+//#endregion
+//#region src/taxpayer/query-taxpayer.ts
+const TAXPAYER_NAMESPACE = "http://www.szamlazz.hu/xmltaxpayer";
+const TAXPAYER_SCHEMA_LOCATION = "http://www.szamlazz.hu/docs/xsds/agent/xmltaxpayer.xsd";
+function toTaxpayerId(taxNumber) {
+	const digits = typeof taxNumber === "string" ? taxNumber.replace(/[\s-]+/g, "").replace(/^HU/i, "") : "";
+	if (!/^(?:\d{8}|\d{11})$/.test(digits)) throw new require_errors.SzamlazzError(`Érvénytelen adószám: "${String(taxNumber)}". Add meg a 8 jegyű törzsszámot vagy a 11 jegyű adószámot (pl. 12345678-2-42).`, {
+		category: "validation",
+		action: "queryTaxpayer"
+	});
+	return digits.slice(0, 8);
+}
+function buildQueryTaxpayerXml(credentials, taxNumber) {
+	return require_serialize.buildXmlDocument({
+		root: "xmltaxpayer",
+		namespace: TAXPAYER_NAMESPACE,
+		schemaLocation: TAXPAYER_SCHEMA_LOCATION,
+		children: [require_serialize.el("beallitasok", credentials), require_serialize.el("torzsszam", toTaxpayerId(taxNumber))]
+	});
+}
+function throwIfNavError(root, response) {
+	const result = require_serialize.findChild(root, "result");
+	if (require_serialize.childText(result, "funcCode")?.toUpperCase() !== "ERROR") return;
+	const errorCode = require_serialize.childText(result, "errorCode");
+	const code = require_errors.parseErrorCode(errorCode);
+	const message = require_serialize.childText(result, "message");
+	const textCode = code === void 0 ? errorCode : void 0;
+	throw require_errors.createAgentError({
+		code,
+		message: textCode === void 0 ? message : [textCode, message].filter(Boolean).join(": "),
+		action: response.action,
+		httpStatus: response.status,
+		rawResponse: response.text().slice(0, 2e3)
+	});
+}
+function readTaxNumber(data) {
+	const detail = require_serialize.findChild(data, "taxNumberDetail");
+	const taxpayerId = require_serialize.childText(detail, "taxpayerId");
+	if (taxpayerId === void 0) return void 0;
+	const vatCode = require_serialize.childText(detail, "vatCode");
+	const countyCode = require_serialize.childText(detail, "countyCode");
+	return {
+		taxpayerId,
+		vatCode,
+		countyCode,
+		formatted: vatCode !== void 0 && countyCode !== void 0 ? `${taxpayerId}-${vatCode}-${countyCode}` : void 0
+	};
+}
+function readAddresses(data) {
+	return require_serialize.findChildren(require_serialize.findChild(data, "taxpayerAddressList"), "taxpayerAddressItem").map(parseTaxpayerAddress);
+}
+function readRequestId(root) {
+	const requestId = require_serialize.childText(require_serialize.findChild(root, "header"), "requestId");
+	return requestId === "-" ? void 0 : requestId;
+}
+function parseQueryTaxpayerResponse(response) {
+	require_parse.throwIfAnyError(response);
+	const root = require_parse.parseResponseXml(response);
+	require_parse.throwIfXmlFailure(root, response);
+	if (root.name !== "QueryTaxpayerResponse") throw require_parse.unexpectedResponse(response, "QueryTaxpayerResponse XML választ vártunk.");
+	throwIfNavError(root, response);
+	const requestId = readRequestId(root);
+	const infoDate = require_serialize.childText(root, "infoDate");
+	const data = require_serialize.findChild(root, "taxpayerData");
+	const validity = require_serialize.childBoolean(root, "taxpayerValidity");
+	if (validity === false || data === void 0) return {
+		valid: validity === true,
+		addresses: [],
+		infoDate,
+		requestId
+	};
+	const addresses = readAddresses(data);
+	return {
+		valid: true,
+		name: require_serialize.childText(data, "taxpayerName"),
+		shortName: require_serialize.childText(data, "taxpayerShortName"),
+		taxNumber: readTaxNumber(data),
+		address: addresses.find((address) => address.type === "HQ") ?? addresses[0],
+		addresses,
+		incorporation: require_serialize.childText(data, "incorporation"),
+		vatGroupMembership: require_serialize.childText(data, "vatGroupMembership"),
+		infoDate,
+		requestId
+	};
+}
+async function queryTaxpayer(ctx, taxNumber, options = {}) {
+	const xml = buildQueryTaxpayerXml(ctx.credentials, taxNumber);
+	return ctx.execute({
+		action: "queryTaxpayer",
+		xml,
+		signal: options.signal,
+		safeToRetry: true
+	}, parseQueryTaxpayerResponse);
+}
+//#endregion
+//#region src/taxpayer/cache.ts
+const TAXPAYER_CACHE_KEY_PREFIX = "szamlazz:taxpayer:";
+const DEFAULT_TAXPAYER_TTL_SECONDS = 86400;
+const DEFAULT_TAXPAYER_INVALID_TTL_SECONDS = 600;
+function positiveSeconds(value, fallback, field) {
+	if (value === void 0) return fallback;
+	if (!Number.isFinite(value) || value < 1) throw new require_errors.SzamlazzError(`A(z) ${field} legalább 1 másodperc legyen, kapott: ${String(value)}`, { category: "configuration" });
+	return Math.ceil(value);
+}
+function parseCached(value) {
+	if (typeof value !== "string" || value === "") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const info = parsed;
+		return typeof info.valid === "boolean" && Array.isArray(info.addresses) ? info : void 0;
+	} catch {
+		return;
+	}
+}
+function cachedTaxpayerQuery(query, options, warn) {
+	const ttl = positiveSeconds(options.ttlSeconds, DEFAULT_TAXPAYER_TTL_SECONDS, "ttlSeconds");
+	const invalidTtl = positiveSeconds(options.invalidTtlSeconds, 600, "invalidTtlSeconds");
+	const report = (operation, error) => warn?.({
+		kind: "cache",
+		message: `Az adószám-gyorsítótár "${operation}" művelete sikertelen, a kassza a Számlázz.hu-tól kérdez.`,
+		error,
+		action: "queryTaxpayer",
+		operation
+	});
+	return async (taxNumber, requestOptions) => {
+		const key = `${TAXPAYER_CACHE_KEY_PREFIX}${toTaxpayerId(taxNumber)}`;
+		try {
+			const cached = parseCached(await options.store.get(key));
+			if (cached) return cached;
+		} catch (error) {
+			report("get", error);
+		}
+		const info = await query(taxNumber, requestOptions);
+		try {
+			await options.store.set(key, JSON.stringify(info), info.valid ? ttl : invalidTtl);
+		} catch (error) {
+			report("set", error);
+		}
+		return info;
+	};
+}
+//#endregion
+//#region src/client.ts
+const CREDENTIAL_PROBE_INVOICE_NUMBER = "KASSZA-CREDENTIAL-PROBE-0";
+async function nullIfNotFound(promise) {
+	try {
+		return await promise;
+	} catch (error) {
+		if (require_errors.isSzamlazzError(error) && (error.isNotFound || error.code === 7)) return null;
+		throw error;
+	}
+}
+function attemptKeyOf(target) {
+	if (typeof target === "string") return target;
+	const key = target.details?.attemptKey;
+	if (key === void 0) throw new TypeError("A resetAttempts egy attempt_limit hibát vagy annak details.attemptKey kulcsát várja.");
+	return key;
+}
+function invoiceNumberOf(input) {
+	return typeof input === "string" ? input : input.invoiceNumber;
+}
+function receiptNumberOf(input) {
+	return typeof input === "string" ? input : input.receiptNumber;
+}
+function createDocumentEmitter(hook, options) {
+	return { emit: (event) => require_create_once.emitDocumentEvent(hook, event, options) };
+}
+function createInvoicesApi(ctx, defaults, events, guard) {
+	const api = {
+		async create(input, options) {
+			const document = await createInvoice(ctx, defaults, input, options);
+			await events.emit({
+				kind: "invoice",
+				action: "created",
+				number: document.number,
+				document,
+				input
+			});
+			return document;
+		},
+		createOnce: (input, options) => require_issue.createInvoiceOnce(api, input, options, guard),
+		preview: (input, options) => previewInvoice(ctx, defaults, input, options),
+		async reverse(input, options) {
+			const document = await reverseInvoice(ctx, input, options);
+			await events.emit({
+				kind: "invoice",
+				action: "reversed",
+				number: document.number,
+				reversedNumber: invoiceNumberOf(input),
+				document
+			});
+			return document;
+		},
+		async registerPayment(input, options) {
+			const document = await require_create_once.registerPayment(ctx, input, options);
+			await events.emit({
+				kind: "invoice",
+				action: "payment",
+				number: document.invoiceNumber,
+				document
+			});
+			return document;
+		},
+		registerPaymentOnce: (input, options) => require_create_once.registerPaymentOnce(api, input, options, guard),
+		async clearPayments(input, options) {
+			const document = await require_create_once.clearPayments(ctx, input, options);
+			await events.emit({
+				kind: "invoice",
+				action: "payment",
+				number: document.invoiceNumber,
+				document
+			});
+			return document;
+		},
+		getPdf: (reference, options) => getInvoicePdf(ctx, reference, options),
+		get: (reference, query, options) => require_get.getInvoice(ctx, reference, query, options),
+		find: (reference, query, options) => nullIfNotFound(require_get.getInvoice(ctx, reference, query, options)),
+		deleteProforma: (reference, options) => deleteProforma(ctx, reference, options)
+	};
+	return api;
+}
+function convertedJoin(result) {
+	return {
+		receipt: result.receipt,
+		invoice: {
+			...result.invoice,
+			created: false
+		}
+	};
+}
+function createReceiptsApi(ctx, defaults, invoices, events, guard) {
+	const api = {
+		async create(input, options) {
+			const document = await require_create.createReceipt(ctx, defaults, input, options);
+			await events.emit({
+				kind: "receipt",
+				action: "created",
+				number: document.number,
+				document
+			});
+			return document;
+		},
+		createOnce: (input, options) => require_create_once.createReceiptOnce(api, input, options, guard),
+		async reverse(input, options) {
+			const document = await reverseReceipt(ctx, input, options);
+			await events.emit({
+				kind: "receipt",
+				action: "reversed",
+				number: document.number,
+				reversedNumber: receiptNumberOf(input),
+				document
+			});
+			return document;
+		},
+		get: (input, options) => getReceipt(ctx, input, options),
+		find: (input, options) => nullIfNotFound(getReceipt(ctx, input, options)),
+		send: (input, options) => sendReceipt(ctx, input, options),
+		convertToInvoice: (input, options = {}) => require_issue.guardOnce(guard, `convert:${input.receiptNumber?.trim() ?? ""}`, {
+			...options,
+			lock: false
+		}, () => require_issue.convertReceiptToInvoice({
+			receipts: api,
+			invoices
+		}, input, options), convertedJoin)
+	};
+	return api;
+}
+function onceScopeOf(ctx) {
+	return ctx.credentials.map((node) => `${node.name}=${String(node.content)}`).join("\n");
+}
+function createKassza(options = {}) {
+	const ctx = createAgentContext(options);
+	const events = createDocumentEmitter(options.hooks?.onDocument, {
+		mode: options.hooks?.onDocumentError,
+		onWarning: options.hooks?.onWarning
+	});
+	const guard = {
+		scope: onceScopeOf(ctx),
+		lock: options.createOnceLock,
+		warn: ctx.warn
+	};
+	const directQuery = (taxNumber, requestOptions) => queryTaxpayer(ctx, taxNumber, requestOptions);
+	const taxpayerQuery = options.taxpayerCache ? cachedTaxpayerQuery(directQuery, options.taxpayerCache, ctx.warn) : directQuery;
+	const invoices = createInvoicesApi(ctx, options.defaults?.invoice ?? {}, events, guard);
+	const receipts = createReceiptsApi(ctx, options.defaults?.receipt ?? {}, invoices, events, guard);
+	return {
+		invoices,
+		receipts,
+		taxpayer: { query: taxpayerQuery },
+		async verifyCredentials(requestOptions) {
+			try {
+				await getInvoicePdf(ctx, CREDENTIAL_PROBE_INVOICE_NUMBER, requestOptions);
+				return true;
+			} catch (error) {
+				if (!require_errors.isSzamlazzError(error)) throw error;
+				if (error.category === "auth") return false;
+				if (error.isNotFound || error.code === 7) return true;
+				throw error;
+			}
+		},
+		resetSession: () => ctx.resetSession(),
+		resetAttempts: (target) => ctx.resetAttempts(attemptKeyOf(target)),
+		issueForPayment: (payment, issueOptions) => require_issue.issueForPayment({
+			invoices,
+			receipts
+		}, payment, issueOptions)
+	};
+}
+//#endregion
+Object.defineProperty(exports, "ATTEMPT_LEDGER_KEY_PREFIX", {
+	enumerable: true,
+	get: function() {
+		return ATTEMPT_LEDGER_KEY_PREFIX;
+	}
+});
+Object.defineProperty(exports, "ATTEMPT_LEDGER_TTL_SECONDS", {
+	enumerable: true,
+	get: function() {
+		return ATTEMPT_LEDGER_TTL_SECONDS;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_TAXPAYER_INVALID_TTL_SECONDS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_TAXPAYER_INVALID_TTL_SECONDS;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_TAXPAYER_TTL_SECONDS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_TAXPAYER_TTL_SECONDS;
+	}
+});
+Object.defineProperty(exports, "TAXPAYER_CACHE_KEY_PREFIX", {
+	enumerable: true,
+	get: function() {
+		return TAXPAYER_CACHE_KEY_PREFIX;
+	}
+});
+Object.defineProperty(exports, "attemptLedgerKey", {
+	enumerable: true,
+	get: function() {
+		return attemptLedgerKey;
+	}
+});
+Object.defineProperty(exports, "buildCreateInvoiceXml", {
+	enumerable: true,
+	get: function() {
+		return buildCreateInvoiceXml;
+	}
+});
+Object.defineProperty(exports, "createAgentContext", {
+	enumerable: true,
+	get: function() {
+		return createAgentContext;
+	}
+});
+Object.defineProperty(exports, "createKassza", {
+	enumerable: true,
+	get: function() {
+		return createKassza;
+	}
+});
+Object.defineProperty(exports, "getInvoicePdf", {
+	enumerable: true,
+	get: function() {
+		return getInvoicePdf;
+	}
+});
+Object.defineProperty(exports, "queryTaxpayer", {
+	enumerable: true,
+	get: function() {
+		return queryTaxpayer;
+	}
+});