kassza 0.11.0 → 0.13.0

package/dist/client-CfaS1-Jx.js

@@ -0,0 +1,1228 @@
+import { c as emitDocumentEvent, i as resolveInvoice, l as AGENT_ACTIONS, n as optionalAgentDate, o as INVOICE_TEMPLATES, r as presentText, s as TAXPAYER_TYPE_CODES, t as createReceiptOnce } from "./create-once-Cz621l8r.js";
+import { a as parseErrorCode, i as isSzamlazzError, n as SzamlazzError, r as createAgentError } from "./errors-DLrb0g64.js";
+import { t as base64ToBytes } from "./binary-D0M9U2MD.js";
+import { a as optionalEl, c as childNumber, d as findChildren, l as childText, n as buildXmlDocument, r as el, s as childBoolean, u as findChild } from "./serialize-DSE_o9RK.js";
+import { a as looksLikeXml, c as readDocumentHeaders, d as throwIfHeaderError, f as throwIfHttpError, h as unexpectedResponse, m as throwIfXmlFailure, n as parseReceiptResponse, o as parseDoneText, p as throwIfTextError, r as createAgentResponse, s as parseResponseXml, u as throwIfAnyError } from "./parse-C608ehqM.js";
+import { i as sessionKeyFor, n as memoryCookieStore, r as mergeSetCookies, t as SESSION_TTL_SECONDS } from "./session-rMKaJcmq.js";
+import { a as todayInBudapest } from "./dates-CXyj7Azy.js";
+import { r as formatVatRate } from "./vat-v_dcWCto.js";
+import { i as summarizeItems } from "./money-t7uy1n91.js";
+import { _ as createInvoiceOnce, c as optionalText, d as validateTemplate$1, l as receiptValidationError, n as issueForPayment, o as createReceipt, p as convertReceiptToInvoice, s as RECEIPT_XSD_BASE_URL, u as requireReceiptNumber } from "./issue-DtSLpVdJ.js";
+import { a as optionalAgentDate$1, c as referenceValue, d as validationError, i as agentDate, l as requireText, o as optionalText$1, r as AGENT_XSD_BASE_URL, s as parseInvoiceResult, t as getInvoice, u as resolveInvoiceReference } from "./get-DT3JEgQ6.js";
+//#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 createAttemptLedger(store) {
+	return {
+		async failures(key) {
+			return parseCount(await store.get(key));
+		},
+		async recordFailure(key, previous) {
+			const next = previous + 1;
+			await store.set(key, String(next), ATTEMPT_LEDGER_TTL_SECONDS);
+			return next;
+		},
+		async reset(key) {
+			await store.delete(key);
+		}
+	};
+}
+function attemptLimitError(action, key, failures) {
+	return new 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;
+function readEnv(name) {
+	const value = (globalThis.process?.env)?.[name]?.trim();
+	return value ? value : void 0;
+}
+function configurationError(message) {
+	return new 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 [el("szamlaagentkulcs", agentKey)];
+	}
+	if (options.username && options.password) return [el("felhasznalo", options.username), 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(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 });
+	});
+}
+async function ignoreStoreFailure(operation) {
+	try {
+		return await operation();
+	} catch {
+		return;
+	}
+}
+function callHook(hook, event) {
+	if (!hook) return;
+	try {
+		const result = hook(event);
+		if (result instanceof Promise) result.catch(() => void 0);
+	} catch {
+		return;
+	}
+}
+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 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 ?? memoryCookieStore();
+	const sessionSecret = credentials.map((node) => String(node.content)).join("|");
+	let sessionKeyPromise;
+	const resolveSessionKey = () => {
+		sessionKeyPromise ??= sessionKeyFor(sessionSecret);
+		return sessionKeyPromise;
+	};
+	const hooks = options.hooks ?? {};
+	const ledger = options.attemptLedger ? createAttemptLedger(options.attemptLedger) : void 0;
+	const cooldownMs = resolveCooldown(options.maintenanceCooldownMs);
+	let blockedUntil = 0;
+	async function send(request) {
+		const cookie = cookieStore ? await ignoreStoreFailure(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 SzamlazzError(`A Számlázz.hu nem válaszolt ${timeoutMs} ms alatt.`, {
+				category: "timeout",
+				action: request.action,
+				cause: error
+			});
+			throw new SzamlazzError("Hálózati hiba a Számlázz.hu elérésekor.", {
+				category: "network",
+				action: request.action,
+				cause: error
+			});
+		}
+		if (cookieStore) {
+			const merged = mergeSetCookies(cookie, response.headers);
+			if (merged) await ignoreStoreFailure(async () => cookieStore.set(await resolveSessionKey(), merged, SESSION_TTL_SECONDS));
+		}
+		return createAgentResponse(request.action, response.status, response.headers, body);
+	}
+	async function resetSession() {
+		if (cookieStore) await ignoreStoreFailure(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 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);
+		for (let attempt = 1;; attempt++) {
+			assertNoCooldown(request.action);
+			const failures = ledger && ledgerKey !== void 0 ? await ignoreStoreFailure(() => ledger.failures(ledgerKey)) ?? 0 : 0;
+			if (ledgerKey !== void 0 && failures >= 5) throw attemptLimitError(request.action, ledgerKey, failures);
+			const startedAt = Date.now();
+			callHook(hooks.onRequest, {
+				action: request.action,
+				attempt
+			});
+			try {
+				const response = await send(request);
+				callHook(hooks.onResponse, {
+					action: request.action,
+					attempt,
+					status: response.status,
+					durationMs: Date.now() - startedAt
+				});
+				const result = await parse(response);
+				if (ledger && ledgerKey !== void 0 && failures > 0) await ignoreStoreFailure(() => ledger.reset(ledgerKey));
+				return result;
+			} catch (error) {
+				if (!(error instanceof SzamlazzError)) throw error;
+				if (ledger && ledgerKey !== void 0 && countsAsFailedAttempt(error)) await ignoreStoreFailure(() => ledger.recordFailure(ledgerKey, failures));
+				if (error.category === "maintenance" && cooldownMs > 0) blockedUntil = Date.now() + cooldownMs;
+				const willRetry = error.retryable && attempt < maxAttempts && !(error.category === "maintenance" && cooldownMs > 0);
+				callHook(hooks.onError, {
+					action: request.action,
+					attempt,
+					error,
+					willRetry
+				});
+				if (error.category === "auth") await resetSession();
+				if (!willRetry) throw error;
+				await sleep(retryDelayMs * 2 ** (attempt - 1), request.signal);
+			}
+		}
+	}
+	return {
+		credentials,
+		execute,
+		resetSession,
+		resetAttempts
+	};
+}
+//#endregion
+//#region src/invoices/create-response.ts
+function readRawResponse(response) {
+	throwIfAnyError(response);
+	const headers = 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 (looksLikeXml(response)) {
+		const root = parseResponseXml(response);
+		throwIfXmlFailure(root, response);
+		const pdfBase64 = childText(root, "pdf");
+		return {
+			number: childText(root, "szamlaszam") ?? headers.number,
+			netTotal: childNumber(root, "szamlanetto") ?? headers.netTotal,
+			grossTotal: childNumber(root, "szamlabrutto") ?? headers.grossTotal,
+			outstanding: childNumber(root, "kintlevoseg"),
+			buyerAccountUrl: childText(root, "vevoifiokurl") ?? headers.buyerAccountUrl,
+			pdf: pdfBase64 === void 0 ? void 0 : base64ToBytes(pdfBase64)
+		};
+	}
+	const done = parseDoneText(response.text());
+	if (done) return {
+		...fromHeaders,
+		number: done.number ?? headers.number
+	};
+	if (headers.number !== void 0) return fromHeaders;
+	throw 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 = 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 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 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 optionalEl(name, presentText(value));
+}
+function settingsNode(credentials, invoice, preview) {
+	return el("beallitasok", [
+		...credentials,
+		el("eszamla", invoice.eInvoice),
+		el("szamlaLetoltes", preview || invoice.downloadPdf),
+		el("valaszVerzio", RESPONSE_VERSION_XML),
+		textEl("aggregator", invoice.aggregator),
+		optionalEl("guardian", invoice.guardian),
+		optionalEl("cikkazoninvoice", invoice.articleIdentifierInvoice),
+		textEl("szamlaKulsoAzon", invoice.input.externalId)
+	]);
+}
+function documentTypeNodes(invoice) {
+	const { input, type } = invoice;
+	return [
+		type === "advance" && el("elolegszamla", true),
+		type === "final" && el("vegszamla", true),
+		input.type === "final" && textEl("elolegSzamlaszam", input.advanceInvoiceNumber),
+		type === "corrective" && el("helyesbitoszamla", true),
+		input.type === "corrective" && textEl("helyesbitettSzamlaszam", input.correctedInvoiceNumber),
+		type === "proforma" && el("dijbekero", true),
+		type === "deliveryNote" && el("szallitolevel", true)
+	];
+}
+function headerNode(invoice, preview) {
+	const { input } = invoice;
+	return el("fejlec", [
+		el("keltDatum", invoice.issueDate),
+		el("teljesitesDatum", invoice.fulfillmentDate),
+		el("fizetesiHataridoDatum", invoice.dueDate),
+		el("fizmod", invoice.paymentMethod),
+		el("penznem", invoice.currency),
+		el("szamlaNyelve", invoice.language),
+		textEl("megjegyzes", input.comment),
+		textEl("arfolyamBank", invoice.exchangeBank),
+		optionalEl("arfolyam", invoice.exchangeRate),
+		textEl("rendelesSzam", input.orderNumber),
+		textEl("dijbekeroSzamlaszam", input.proformaNumber),
+		...documentTypeNodes(invoice),
+		textEl("logoExtra", invoice.logoExtra),
+		textEl("szamlaszamElotag", invoice.prefix),
+		optionalEl("fizetendoKorrekcio", input.paymentCorrection),
+		optionalEl("fizetve", input.paid),
+		optionalEl("arresAfa", input.marginVat),
+		optionalEl("eusAfa", invoice.euVat),
+		optionalEl("szamlaSablon", invoice.template),
+		preview && el("elonezetpdf", true),
+		optionalEl("simpleItems", invoice.simpleItems)
+	]);
+}
+function sellerNode(seller) {
+	return 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 optionalEl("vevoFokonyv", [
+		optionalEl("konyvelesDatum", optionalAgentDate(ledger.bookingDate, "buyer.ledger.bookingDate")),
+		textEl("vevoAzonosito", ledger.buyerId),
+		textEl("vevoFokonyviSzam", ledger.ledgerAccount),
+		optionalEl("folyamatosTelj", ledger.continuousFulfillment),
+		optionalEl("elszDatumTol", optionalAgentDate(ledger.settlementPeriodStart, "buyer.ledger.settlementPeriodStart")),
+		optionalEl("elszDatumIg", optionalAgentDate(ledger.settlementPeriodEnd, "buyer.ledger.settlementPeriodEnd"))
+	]);
+}
+function buyerNode(buyer, sendEmail) {
+	const taxpayerType = buyer.taxpayerType;
+	return el("vevo", [
+		el("nev", buyer.name),
+		textEl("orszag", buyer.country),
+		el("irsz", buyer.zip),
+		el("telepules", buyer.city),
+		el("cim", buyer.address),
+		textEl("email", buyer.email),
+		el("sendEmail", sendEmail),
+		optionalEl("adoalany", taxpayerType === void 0 ? void 0 : 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 el("fuvarlevel", [
+		textEl("futarSzolgalat", waybill.courier),
+		textEl("vonalkod", waybill.barcode),
+		textEl("megjegyzes", waybill.comment),
+		tof && el("tof", [
+			textEl("azonosito", tof.id),
+			textEl("shipmentID", tof.shipmentId),
+			optionalEl("csomagszam", tof.packageCount),
+			textEl("countryCode", tof.countryCode),
+			textEl("zip", tof.zip),
+			textEl("service", tof.service)
+		]),
+		ppp && el("ppp", [textEl("vonalkodPrefix", ppp.barcodePrefix), textEl("vonalkodPostfix", ppp.barcodePostfix)]),
+		sprinter && el("sprinter", [
+			textEl("azonosito", sprinter.id),
+			textEl("feladokod", sprinter.senderCode),
+			textEl("iranykod", sprinter.directionCode),
+			optionalEl("csomagszam", sprinter.packageCount),
+			textEl("vonalkodPostfix", sprinter.barcodePostfix),
+			textEl("szallitasiIdo", sprinter.deliveryTime)
+		]),
+		mpl && el("mpl", [
+			el("vevokod", mpl.customerCode),
+			el("vonalkod", mpl.barcode),
+			el("tomeg", String(mpl.weight)),
+			textEl("kulonszolgaltatasok", mpl.services),
+			optionalEl("erteknyilvanitas", mpl.declaredValue)
+		])
+	]);
+}
+function itemLedgerNode(ledger, label) {
+	if (!ledger) return void 0;
+	return optionalEl("tetelFokonyv", [
+		textEl("gazdasagiEsem", ledger.economicEvent),
+		textEl("gazdasagiEsemAfa", ledger.vatEconomicEvent),
+		textEl("arbevetelFokonyviSzam", ledger.revenueLedgerAccount),
+		textEl("afaFokonyviSzam", ledger.vatLedgerAccount),
+		optionalEl("elszDatumTol", optionalAgentDate(ledger.settlementPeriodStart, `${label} settlementPeriodStart`)),
+		optionalEl("elszDatumIg", optionalAgentDate(ledger.settlementPeriodEnd, `${label} settlementPeriodEnd`))
+	]);
+}
+function itemNode(item, index) {
+	const { input, amounts } = item;
+	return el("tetel", [
+		el("megnevezes", input.name),
+		textEl("azonosito", input.identifier),
+		el("mennyiseg", amounts.quantity),
+		el("mennyisegiEgyseg", item.unit),
+		el("nettoEgysegar", amounts.netUnitPrice),
+		el("afakulcs", formatVatRate(amounts.vat)),
+		optionalEl("arresAfaAlap", input.marginVatBase),
+		el("nettoErtek", amounts.netAmount),
+		el("afaErtek", amounts.vatAmount),
+		el("bruttoErtek", amounts.grossAmount),
+		textEl("megjegyzes", input.comment),
+		itemLedgerNode(input.ledger, `${index + 1}. tétel ledger`),
+		optionalEl("torloKod", input.dataDeletionCode)
+	]);
+}
+function renderInvoiceXml(credentials, invoice, options = {}) {
+	const preview = options.preview === true;
+	return 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),
+			el("tetelek", invoice.items.map(itemNode))
+		]
+	});
+}
+function buildCreateInvoiceXml(credentials, defaults, input, now = /* @__PURE__ */ new Date()) {
+	return renderInvoiceXml(credentials, 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 = 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 = resolveInvoice(defaults, input, /* @__PURE__ */ new Date());
+	const items = itemsOf(invoice);
+	return ctx.execute(buildRequest(ctx, invoice, true, options), (response) => parseInvoicePreviewResponse(response, items));
+}
+function normalizeRegisterInput(input) {
+	const payments = "payments" in input ? input.payments : [{
+		amount: input.amount,
+		method: input.method ?? "átutalás",
+		date: input.date,
+		description: input.description
+	}];
+	if (!Array.isArray(payments) || payments.length === 0) throw validationError("Adj meg legalább egy befizetést (payments). A korábbi befizetések törléséhez a clearPayments függvényt használd.");
+	if (payments.length > 5) throw validationError(`Egy kérésben legfeljebb 5 befizetés rögzíthető, kapott: ${payments.length}.`);
+	return {
+		invoiceNumber: input.invoiceNumber,
+		taxNumber: input.taxNumber,
+		additive: input.additive ?? true,
+		payments
+	};
+}
+function normalizeClearInput(input) {
+	const target = typeof input === "string" ? { invoiceNumber: input } : input;
+	return {
+		invoiceNumber: target.invoiceNumber,
+		taxNumber: target.taxNumber,
+		additive: false,
+		payments: []
+	};
+}
+function paymentNode(payment, index) {
+	const position = index + 1;
+	if (typeof payment.amount !== "number" || !Number.isFinite(payment.amount)) throw validationError(`A(z) ${position}. befizetés összege (amount) nem véges szám.`);
+	return el("kifizetes", [
+		el("datum", payment.date === void 0 ? todayInBudapest() : agentDate(payment.date, "date")),
+		el("jogcim", requireText(payment.method, `Add meg a(z) ${position}. befizetés módját (method).`)),
+		el("osszeg", payment.amount),
+		optionalEl("leiras", optionalText$1(payment.description))
+	]);
+}
+function buildPaymentXml(credentials, request) {
+	const invoiceNumber = requireText(request.invoiceNumber, "Add meg a számla számát (invoiceNumber), amelyhez a befizetés tartozik.");
+	return buildXmlDocument({
+		root: "xmlszamlakifiz",
+		namespace: "http://www.szamlazz.hu/xmlszamlakifiz",
+		schemaLocation: `${AGENT_XSD_BASE_URL}agentkifiz/xmlszamlakifiz.xsd`,
+		children: [el("beallitasok", [
+			...credentials,
+			el("szamlaszam", invoiceNumber),
+			optionalEl("adoszam", optionalText$1(request.taxNumber)),
+			el("additiv", request.additive),
+			el("valaszVerzio", 2)
+		]), ...request.payments.map(paymentNode)]
+	});
+}
+function parseRegisterPaymentResponse(response, invoiceNumber) {
+	const result = parseInvoiceResult(response);
+	return {
+		invoiceNumber: result.number ?? invoiceNumber.trim(),
+		netTotal: result.netTotal,
+		grossTotal: result.grossTotal,
+		outstanding: result.outstanding,
+		buyerAccountUrl: result.buyerAccountUrl
+	};
+}
+function sendPaymentRequest(ctx, request, options) {
+	const xml = buildPaymentXml(ctx.credentials, request);
+	return ctx.execute({
+		action: "registerPayment",
+		xml,
+		signal: options.signal,
+		safeToRetry: !request.additive
+	}, (response) => parseRegisterPaymentResponse(response, request.invoiceNumber));
+}
+async function registerPayment(ctx, input, options = {}) {
+	return sendPaymentRequest(ctx, normalizeRegisterInput(input), options);
+}
+async function clearPayments(ctx, input, options = {}) {
+	return sendPaymentRequest(ctx, normalizeClearInput(input), options);
+}
+//#endregion
+//#region src/invoices/pdf.ts
+function buildInvoicePdfXml(credentials, reference) {
+	const resolved = resolveInvoiceReference(reference);
+	return buildXmlDocument({
+		root: "xmlszamlapdf",
+		namespace: "http://www.szamlazz.hu/xmlszamlapdf",
+		schemaLocation: `${AGENT_XSD_BASE_URL}agentpdf/xmlszamlapdf.xsd`,
+		children: [
+			...credentials,
+			optionalEl("szamlaszam", referenceValue(resolved, "invoiceNumber")),
+			optionalEl("rendelesSzam", referenceValue(resolved, "orderNumber")),
+			el("valaszVerzio", 2),
+			optionalEl("szamlaKulsoAzon", referenceValue(resolved, "externalId"))
+		]
+	});
+}
+function parseInvoicePdfResponse(response) {
+	const { pdf, ...rest } = parseInvoiceResult(response);
+	if (pdf === void 0 || pdf.length === 0) throw 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: requireText(reference, `Üres díjbekérőszám. ${REFERENCE_HINT}`) };
+	if (typeof reference !== "object" || reference === null) throw 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 validationError(`Érvénytelen díjbekérő-hivatkozás. ${REFERENCE_HINT}`);
+	return hasNumber ? { proformaNumber: requireText(record.proformaNumber, `Üres proformaNumber. ${REFERENCE_HINT}`) } : { orderNumber: requireText(record.orderNumber, `Üres orderNumber. ${REFERENCE_HINT}`) };
+}
+function buildDeleteProformaXml(credentials, reference) {
+	const resolved = resolveProformaReference(reference);
+	return buildXmlDocument({
+		root: "xmlszamladbkdel",
+		namespace: "http://www.szamlazz.hu/xmlszamladbkdel",
+		schemaLocation: "http://www.szamlazz.hu/docs/xsds/szamladbkdel/xmlszamladbkdel.xsd",
+		children: [el("beallitasok", [...credentials]), el("fejlec", [optionalEl("szamlaszam", resolved.proformaNumber), optionalEl("rendelesszam", resolved.orderNumber)])]
+	});
+}
+function withProformaCategory(error) {
+	if (!(error instanceof SzamlazzError) || error.code !== 335) return error;
+	return new 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 {
+		throwIfHeaderError(response);
+		throwIfTextError(response);
+		throwIfHttpError(response);
+		const root = parseResponseXml(response);
+		throwIfXmlFailure(root, response);
+		if (!RESPONSE_ROOTS.has(root.name) || childText(root, "sikeres")?.toLowerCase() !== "true") throw 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(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 validationError(`Ismeretlen számlasablon: ${String(template)}. Lehetséges értékek: ${INVOICE_TEMPLATES.join(", ")}.`);
+}
+function buildReverseInvoiceXml(credentials, input) {
+	const options = normalizeInput$2(input);
+	const invoiceNumber = requireText(options.invoiceNumber, "Add meg a sztornózandó számla számát (invoiceNumber).");
+	const email = options.email;
+	const buyer = options.buyer;
+	return buildXmlDocument({
+		root: "xmlszamlast",
+		namespace: "http://www.szamlazz.hu/xmlszamlast",
+		schemaLocation: `${AGENT_XSD_BASE_URL}agentst/xmlszamlast.xsd`,
+		children: [
+			el("beallitasok", [
+				...credentials,
+				el("eszamla", options.eInvoice ?? false),
+				el("szamlaLetoltes", options.downloadPdf ?? true),
+				el("valaszVerzio", 2),
+				optionalEl("szamlaKulsoAzon", optionalText$1(options.externalId))
+			]),
+			el("fejlec", [
+				el("szamlaszam", invoiceNumber),
+				optionalEl("keltDatum", optionalAgentDate$1(options.issueDate, "issueDate")),
+				optionalEl("teljesitesDatum", optionalAgentDate$1(options.fulfillmentDate, "fulfillmentDate")),
+				optionalEl("megjegyzes", optionalText$1(options.comment)),
+				el("tipus", "SS"),
+				optionalEl("szamlaSablon", validateTemplate(options.template))
+			]),
+			optionalEl("elado", [
+				optionalEl("emailReplyto", optionalText$1(email?.replyTo)),
+				optionalEl("emailTargy", optionalText$1(email?.subject)),
+				optionalEl("emailSzoveg", optionalText$1(email?.text))
+			]),
+			optionalEl("vevo", [
+				optionalEl("email", optionalText$1(buyer?.email)),
+				optionalEl("adoszam", optionalText$1(buyer?.taxNumber)),
+				optionalEl("adoszamEU", optionalText$1(buyer?.euTaxNumber))
+			])
+		]
+	});
+}
+function parseReverseInvoiceResponse(response, originalInvoiceNumber) {
+	const result = parseInvoiceResult(response);
+	if (result.number === void 0) throw unexpectedResponse(response, "A válaszban nincs sztornó számlaszám.");
+	if (originalInvoiceNumber !== void 0 && result.number === originalInvoiceNumber.trim()) throw new 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 = optionalText(input.receiptNumber);
+	const orderNumber = optionalText(input.orderNumber);
+	if (receiptNumber === void 0 && orderNumber === void 0) throw 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 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 buildXmlDocument({
+		root: "xmlnyugtaget",
+		namespace: GET_RECEIPT_NAMESPACE,
+		schemaLocation: `${RECEIPT_XSD_BASE_URL}nyugtaget/xmlnyugtaget.xsd`,
+		children: [el("beallitasok", [...credentials, el("pdfLetoltes", normalized.downloadPdf ?? true)]), el("fejlec", [
+			optionalEl("nyugtaszam", receiptNumber),
+			optionalEl("rendelesSzam", orderNumber),
+			optionalEl("hivasAzonosito", optionalText(normalized.callId)),
+			optionalEl("pdfSablon", validateTemplate$1(normalized.template))
+		])]
+	});
+}
+function getReceipt(ctx, input, options = {}) {
+	const xml = buildGetReceiptXml(ctx.credentials, input);
+	return ctx.execute({
+		action: "getReceipt",
+		xml,
+		signal: options.signal,
+		safeToRetry: true
+	}, 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 buildXmlDocument({
+		root: "xmlnyugtast",
+		namespace: REVERSE_RECEIPT_NAMESPACE,
+		schemaLocation: `${RECEIPT_XSD_BASE_URL}nyugtast/xmlnyugtast.xsd`,
+		children: [el("beallitasok", [...credentials, el("pdfLetoltes", normalized.downloadPdf ?? true)]), el("fejlec", [
+			el("nyugtaszam", requireReceiptNumber(normalized.receiptNumber)),
+			optionalEl("pdfSablon", validateTemplate$1(normalized.template)),
+			optionalEl("hivasAzonosito", 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: optionalText(normalized.callId) !== void 0
+	}, 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 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 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 = requireReceiptNumber(input.receiptNumber);
+	const emails = normalizeEmails(input.emails);
+	const replyTo = optionalText(input.replyTo);
+	if (replyTo !== void 0) assertEmail(replyTo, "replyTo");
+	return buildXmlDocument({
+		root: "xmlnyugtasend",
+		namespace: SEND_RECEIPT_NAMESPACE,
+		schemaLocation: `${RECEIPT_XSD_BASE_URL}nyugtasend/xmlnyugtasend.xsd`,
+		children: [
+			el("beallitasok", credentials),
+			el("fejlec", [el("nyugtaszam", receiptNumber)]),
+			el("emailKuldes", [
+				el("email", emails.join(",")),
+				optionalEl("emailReplyto", replyTo),
+				el("emailTargy", optionalText(input.subject) ?? `Nyugta ${receiptNumber}`),
+				optionalEl("emailSzoveg", input.text?.trim() ? input.text : void 0)
+			])
+		]
+	});
+}
+function parseSendReceiptResponse(response) {
+	throwIfHeaderError(response);
+	throwIfTextError(response);
+	if (!looksLikeXml(response)) {
+		throwIfHttpError(response);
+		if (parseDoneText(response.text())) return;
+		throw unexpectedResponse(response, "XML választ vártunk a nyugta kiküldésére.");
+	}
+	const root = parseResponseXml(response);
+	throwIfXmlFailure(root, response);
+	if (childBoolean(root, "sikeres") !== true) {
+		throwIfHttpError(response);
+		throw 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: childText(element, "countryCode"),
+		region: childText(element, "region"),
+		postalCode: childText(element, "postalCode"),
+		city: childText(element, "city"),
+		streetName: childText(element, "streetName"),
+		publicPlaceCategory: childText(element, "publicPlaceCategory"),
+		number: childText(element, "number"),
+		building: childText(element, "building"),
+		staircase: childText(element, "staircase"),
+		floor: childText(element, "floor"),
+		door: childText(element, "door"),
+		lotNumber: childText(element, "lotNumber")
+	};
+}
+function parseTaxpayerAddress(item) {
+	const raw = readDetailedAddress(findChild(item, "taxpayerAddress"));
+	const address = {
+		type: 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 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 buildXmlDocument({
+		root: "xmltaxpayer",
+		namespace: TAXPAYER_NAMESPACE,
+		schemaLocation: TAXPAYER_SCHEMA_LOCATION,
+		children: [el("beallitasok", credentials), el("torzsszam", toTaxpayerId(taxNumber))]
+	});
+}
+function throwIfNavError(root, response) {
+	const result = findChild(root, "result");
+	if (childText(result, "funcCode")?.toUpperCase() !== "ERROR") return;
+	const errorCode = childText(result, "errorCode");
+	const code = parseErrorCode(errorCode);
+	const message = childText(result, "message");
+	const textCode = code === void 0 ? errorCode : void 0;
+	throw 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 = findChild(data, "taxNumberDetail");
+	const taxpayerId = childText(detail, "taxpayerId");
+	if (taxpayerId === void 0) return void 0;
+	const vatCode = childText(detail, "vatCode");
+	const countyCode = childText(detail, "countyCode");
+	return {
+		taxpayerId,
+		vatCode,
+		countyCode,
+		formatted: vatCode !== void 0 && countyCode !== void 0 ? `${taxpayerId}-${vatCode}-${countyCode}` : void 0
+	};
+}
+function readAddresses(data) {
+	return findChildren(findChild(data, "taxpayerAddressList"), "taxpayerAddressItem").map(parseTaxpayerAddress);
+}
+function readRequestId(root) {
+	const requestId = childText(findChild(root, "header"), "requestId");
+	return requestId === "-" ? void 0 : requestId;
+}
+function parseQueryTaxpayerResponse(response) {
+	throwIfAnyError(response);
+	const root = parseResponseXml(response);
+	throwIfXmlFailure(root, response);
+	if (root.name !== "QueryTaxpayerResponse") throw unexpectedResponse(response, "QueryTaxpayerResponse XML választ vártunk.");
+	throwIfNavError(root, response);
+	const requestId = readRequestId(root);
+	const infoDate = childText(root, "infoDate");
+	const data = findChild(root, "taxpayerData");
+	const validity = childBoolean(root, "taxpayerValidity");
+	if (validity === false || data === void 0) return {
+		valid: validity === true,
+		addresses: [],
+		infoDate,
+		requestId
+	};
+	const addresses = readAddresses(data);
+	return {
+		valid: true,
+		name: childText(data, "taxpayerName"),
+		shortName: childText(data, "taxpayerShortName"),
+		taxNumber: readTaxNumber(data),
+		address: addresses.find((address) => address.type === "HQ") ?? addresses[0],
+		addresses,
+		incorporation: childText(data, "incorporation"),
+		vatGroupMembership: 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/client.ts
+const CREDENTIAL_PROBE_INVOICE_NUMBER = "KASSZA-CREDENTIAL-PROBE-0";
+async function nullIfNotFound(promise) {
+	try {
+		return await promise;
+	} catch (error) {
+		if (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 createInvoicesApi(ctx, defaults, onDocument) {
+	const api = {
+		async create(input, options) {
+			const document = await createInvoice(ctx, defaults, input, options);
+			await emitDocumentEvent(onDocument, {
+				kind: "invoice",
+				action: "created",
+				number: document.number,
+				document,
+				input
+			});
+			return document;
+		},
+		createOnce: (input, options) => createInvoiceOnce(api, input, options),
+		preview: (input, options) => previewInvoice(ctx, defaults, input, options),
+		async reverse(input, options) {
+			const document = await reverseInvoice(ctx, input, options);
+			await emitDocumentEvent(onDocument, {
+				kind: "invoice",
+				action: "reversed",
+				number: document.number,
+				reversedNumber: invoiceNumberOf(input),
+				document
+			});
+			return document;
+		},
+		async registerPayment(input, options) {
+			const document = await registerPayment(ctx, input, options);
+			await emitDocumentEvent(onDocument, {
+				kind: "invoice",
+				action: "payment",
+				number: document.invoiceNumber,
+				document
+			});
+			return document;
+		},
+		async clearPayments(input, options) {
+			const document = await clearPayments(ctx, input, options);
+			await emitDocumentEvent(onDocument, {
+				kind: "invoice",
+				action: "payment",
+				number: document.invoiceNumber,
+				document
+			});
+			return document;
+		},
+		getPdf: (reference, options) => getInvoicePdf(ctx, reference, options),
+		get: (reference, query, options) => getInvoice(ctx, reference, query, options),
+		find: (reference, query, options) => nullIfNotFound(getInvoice(ctx, reference, query, options)),
+		deleteProforma: (reference, options) => deleteProforma(ctx, reference, options)
+	};
+	return api;
+}
+function createReceiptsApi(ctx, defaults, invoices, onDocument) {
+	const api = {
+		async create(input, options) {
+			const document = await createReceipt(ctx, defaults, input, options);
+			await emitDocumentEvent(onDocument, {
+				kind: "receipt",
+				action: "created",
+				number: document.number,
+				document
+			});
+			return document;
+		},
+		createOnce: (input, options) => createReceiptOnce(api, input, options),
+		async reverse(input, options) {
+			const document = await reverseReceipt(ctx, input, options);
+			await emitDocumentEvent(onDocument, {
+				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) => convertReceiptToInvoice({
+			receipts: api,
+			invoices
+		}, input, options)
+	};
+	return api;
+}
+function createKassza(options = {}) {
+	const ctx = createAgentContext(options);
+	const onDocument = options.hooks?.onDocument;
+	const invoices = createInvoicesApi(ctx, options.defaults?.invoice ?? {}, onDocument);
+	const receipts = createReceiptsApi(ctx, options.defaults?.receipt ?? {}, invoices, onDocument);
+	return {
+		invoices,
+		receipts,
+		taxpayer: { query: (taxNumber, requestOptions) => queryTaxpayer(ctx, taxNumber, requestOptions) },
+		async verifyCredentials(requestOptions) {
+			try {
+				await getInvoicePdf(ctx, CREDENTIAL_PROBE_INVOICE_NUMBER, requestOptions);
+				return true;
+			} catch (error) {
+				if (!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) => issueForPayment({
+			invoices,
+			receipts
+		}, payment, issueOptions)
+	};
+}
+//#endregion
+export { createAgentContext as a, attemptLedgerKey as c, buildCreateInvoiceXml as i, queryTaxpayer as n, ATTEMPT_LEDGER_KEY_PREFIX as o, getInvoicePdf as r, ATTEMPT_LEDGER_TTL_SECONDS as s, createKassza as t };