kassza 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1406 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_create = require("./create-BZd6CUO7.cjs");
+const require_errors = require("./errors-B0QJhUW1.cjs");
+const require_binary = require("./binary-B89HM03_.cjs");
+const require_session = require("./session-CRGOuz-R.cjs");
+const require_dates = require("./dates-PPxH0n5H.cjs");
+const require_money = require("./money-DkiGukAw.cjs");
+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 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_create.el("szamlaagentkulcs", agentKey)];
+	}
+	if (options.username && options.password) return [require_create.el("felhasznalo", options.username), require_create.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.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 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 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 sessionKey = require_session.sessionKeyFor(credentials.map((node) => String(node.content)).join("|"));
+	const hooks = options.hooks ?? {};
+	async function send(request) {
+		const cookie = cookieStore ? await ignoreStoreFailure(() => cookieStore.get(sessionKey)) : 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;
+		try {
+			response = await fetchImpl(endpoint, {
+				method: "POST",
+				headers,
+				body: buildFormData(request),
+				signal
+			});
+		} 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
+			});
+		}
+		const body = new Uint8Array(await response.arrayBuffer());
+		if (cookieStore) {
+			const merged = require_session.mergeSetCookies(cookie, response.headers);
+			if (merged) await ignoreStoreFailure(() => cookieStore.set(sessionKey, merged, require_session.SESSION_TTL_SECONDS));
+		}
+		return require_create.createAgentResponse(request.action, response.status, response.headers, body);
+	}
+	async function resetSession() {
+		if (cookieStore) await ignoreStoreFailure(() => cookieStore.delete(sessionKey));
+	}
+	async function execute(request, parse) {
+		const maxAttempts = request.safeToRetry ? safeAttempts : 1;
+		for (let attempt = 1;; attempt++) {
+			const startedAt = Date.now();
+			hooks.onRequest?.({
+				action: request.action,
+				attempt
+			});
+			try {
+				const response = await send(request);
+				hooks.onResponse?.({
+					action: request.action,
+					attempt,
+					status: response.status,
+					durationMs: Date.now() - startedAt
+				});
+				return await parse(response);
+			} catch (error) {
+				if (!(error instanceof require_errors.SzamlazzError)) throw error;
+				const willRetry = error.retryable && attempt < maxAttempts;
+				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
+	};
+}
+//#endregion
+//#region src/invoices/create-response.ts
+function readRawResponse(response) {
+	require_create.throwIfAnyError(response);
+	const headers = require_create.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_create.looksLikeXml(response)) {
+		const root = require_create.parseResponseXml(response);
+		require_create.throwIfXmlFailure(root, response);
+		const pdfBase64 = require_create.childText(root, "pdf");
+		return {
+			number: require_create.childText(root, "szamlaszam") ?? headers.number,
+			netTotal: require_create.childNumber(root, "szamlanetto") ?? headers.netTotal,
+			grossTotal: require_create.childNumber(root, "szamlabrutto") ?? headers.grossTotal,
+			outstanding: require_create.childNumber(root, "kintlevoseg"),
+			buyerAccountUrl: require_create.childText(root, "vevoifiokurl") ?? headers.buyerAccountUrl,
+			pdf: pdfBase64 === void 0 ? void 0 : require_binary.base64ToBytes(pdfBase64)
+		};
+	}
+	const done = require_create.parseDoneText(response.text());
+	if (done) return {
+		...fromHeaders,
+		number: done.number ?? headers.number
+	};
+	if (headers.number !== void 0) return fromHeaders;
+	throw require_create.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_create.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_create.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_create.optionalEl(name, require_create.presentText(value));
+}
+function settingsNode(credentials, invoice, preview) {
+	return require_create.el("beallitasok", [
+		...credentials,
+		require_create.el("eszamla", invoice.eInvoice),
+		require_create.el("szamlaLetoltes", preview || invoice.downloadPdf),
+		require_create.el("valaszVerzio", RESPONSE_VERSION_XML),
+		textEl("aggregator", invoice.aggregator),
+		require_create.optionalEl("guardian", invoice.guardian),
+		require_create.optionalEl("cikkazoninvoice", invoice.articleIdentifierInvoice),
+		textEl("szamlaKulsoAzon", invoice.input.externalId)
+	]);
+}
+function documentTypeNodes(invoice) {
+	const { input, type } = invoice;
+	return [
+		type === "advance" && require_create.el("elolegszamla", true),
+		type === "final" && require_create.el("vegszamla", true),
+		input.type === "final" && textEl("elolegSzamlaszam", input.advanceInvoiceNumber),
+		type === "corrective" && require_create.el("helyesbitoszamla", true),
+		input.type === "corrective" && textEl("helyesbitettSzamlaszam", input.correctedInvoiceNumber),
+		type === "proforma" && require_create.el("dijbekero", true),
+		type === "deliveryNote" && require_create.el("szallitolevel", true)
+	];
+}
+function headerNode(invoice, preview) {
+	const { input } = invoice;
+	return require_create.el("fejlec", [
+		require_create.el("keltDatum", invoice.issueDate),
+		require_create.el("teljesitesDatum", invoice.fulfillmentDate),
+		require_create.el("fizetesiHataridoDatum", invoice.dueDate),
+		require_create.el("fizmod", invoice.paymentMethod),
+		require_create.el("penznem", invoice.currency),
+		require_create.el("szamlaNyelve", invoice.language),
+		textEl("megjegyzes", input.comment),
+		textEl("arfolyamBank", invoice.exchangeBank),
+		require_create.optionalEl("arfolyam", invoice.exchangeRate),
+		textEl("rendelesSzam", input.orderNumber),
+		textEl("dijbekeroSzamlaszam", input.proformaNumber),
+		...documentTypeNodes(invoice),
+		textEl("logoExtra", invoice.logoExtra),
+		textEl("szamlaszamElotag", invoice.prefix),
+		require_create.optionalEl("fizetendoKorrekcio", input.paymentCorrection),
+		require_create.optionalEl("fizetve", input.paid),
+		require_create.optionalEl("arresAfa", input.marginVat),
+		require_create.optionalEl("eusAfa", invoice.euVat),
+		require_create.optionalEl("szamlaSablon", invoice.template),
+		preview && require_create.el("elonezetpdf", true),
+		require_create.optionalEl("simpleItems", invoice.simpleItems)
+	]);
+}
+function sellerNode(seller) {
+	return require_create.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_create.optionalEl("vevoFokonyv", [
+		require_create.optionalEl("konyvelesDatum", require_create.optionalAgentDate(ledger.bookingDate, "buyer.ledger.bookingDate")),
+		textEl("vevoAzonosito", ledger.buyerId),
+		textEl("vevoFokonyviSzam", ledger.ledgerAccount),
+		require_create.optionalEl("folyamatosTelj", ledger.continuousFulfillment),
+		require_create.optionalEl("elszDatumTol", require_create.optionalAgentDate(ledger.settlementPeriodStart, "buyer.ledger.settlementPeriodStart")),
+		require_create.optionalEl("elszDatumIg", require_create.optionalAgentDate(ledger.settlementPeriodEnd, "buyer.ledger.settlementPeriodEnd"))
+	]);
+}
+function buyerNode(buyer, sendEmail) {
+	const taxpayerType = buyer.taxpayerType;
+	return require_create.el("vevo", [
+		require_create.el("nev", buyer.name),
+		textEl("orszag", buyer.country),
+		require_create.el("irsz", buyer.zip),
+		require_create.el("telepules", buyer.city),
+		require_create.el("cim", buyer.address),
+		textEl("email", buyer.email),
+		require_create.el("sendEmail", sendEmail),
+		require_create.optionalEl("adoalany", taxpayerType === void 0 ? void 0 : require_create.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_create.el("fuvarlevel", [
+		textEl("futarSzolgalat", waybill.courier),
+		textEl("vonalkod", waybill.barcode),
+		textEl("megjegyzes", waybill.comment),
+		tof && require_create.el("tof", [
+			textEl("azonosito", tof.id),
+			textEl("shipmentID", tof.shipmentId),
+			require_create.optionalEl("csomagszam", tof.packageCount),
+			textEl("countryCode", tof.countryCode),
+			textEl("zip", tof.zip),
+			textEl("service", tof.service)
+		]),
+		ppp && require_create.el("ppp", [textEl("vonalkodPrefix", ppp.barcodePrefix), textEl("vonalkodPostfix", ppp.barcodePostfix)]),
+		sprinter && require_create.el("sprinter", [
+			textEl("azonosito", sprinter.id),
+			textEl("feladokod", sprinter.senderCode),
+			textEl("iranykod", sprinter.directionCode),
+			require_create.optionalEl("csomagszam", sprinter.packageCount),
+			textEl("vonalkodPostfix", sprinter.barcodePostfix),
+			textEl("szallitasiIdo", sprinter.deliveryTime)
+		]),
+		mpl && require_create.el("mpl", [
+			require_create.el("vevokod", mpl.customerCode),
+			require_create.el("vonalkod", mpl.barcode),
+			require_create.el("tomeg", String(mpl.weight)),
+			textEl("kulonszolgaltatasok", mpl.services),
+			require_create.optionalEl("erteknyilvanitas", mpl.declaredValue)
+		])
+	]);
+}
+function itemLedgerNode(ledger, label) {
+	if (!ledger) return void 0;
+	return require_create.optionalEl("tetelFokonyv", [
+		textEl("gazdasagiEsem", ledger.economicEvent),
+		textEl("gazdasagiEsemAfa", ledger.vatEconomicEvent),
+		textEl("arbevetelFokonyviSzam", ledger.revenueLedgerAccount),
+		textEl("afaFokonyviSzam", ledger.vatLedgerAccount),
+		require_create.optionalEl("elszDatumTol", require_create.optionalAgentDate(ledger.settlementPeriodStart, `${label} settlementPeriodStart`)),
+		require_create.optionalEl("elszDatumIg", require_create.optionalAgentDate(ledger.settlementPeriodEnd, `${label} settlementPeriodEnd`))
+	]);
+}
+function itemNode(item, index) {
+	const { input, amounts } = item;
+	return require_create.el("tetel", [
+		require_create.el("megnevezes", input.name),
+		textEl("azonosito", input.identifier),
+		require_create.el("mennyiseg", amounts.quantity),
+		require_create.el("mennyisegiEgyseg", item.unit),
+		require_create.el("nettoEgysegar", amounts.netUnitPrice),
+		require_create.el("afakulcs", require_money.formatVatRate(amounts.vat)),
+		require_create.optionalEl("arresAfaAlap", input.marginVatBase),
+		require_create.el("nettoErtek", amounts.netAmount),
+		require_create.el("afaErtek", amounts.vatAmount),
+		require_create.el("bruttoErtek", amounts.grossAmount),
+		textEl("megjegyzes", input.comment),
+		itemLedgerNode(input.ledger, `${index + 1}. tétel ledger`),
+		require_create.optionalEl("torloKod", input.dataDeletionCode)
+	]);
+}
+function renderInvoiceXml(credentials, invoice, options = {}) {
+	const preview = options.preview === true;
+	return require_create.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_create.el("tetelek", invoice.items.map(itemNode))
+		]
+	});
+}
+//#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.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.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/reference.ts
+const AGENT_XSD_BASE_URL = "https://www.szamlazz.hu/szamla/docs/xsds/";
+function validationError(message) {
+	return new require_errors.SzamlazzError(message, { category: "validation" });
+}
+function requireText(value, message) {
+	const trimmed = typeof value === "string" ? value.trim() : "";
+	if (trimmed === "") throw validationError(message);
+	return trimmed;
+}
+function optionalText(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function agentDate(input, field) {
+	try {
+		return require_dates.toAgentDate(input);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		throw new require_errors.SzamlazzError(`Érvénytelen dátum (${field}): ${detail}`, {
+			category: "validation",
+			cause: error
+		});
+	}
+}
+function optionalAgentDate(input, field) {
+	return input === void 0 ? void 0 : agentDate(input, field);
+}
+const REFERENCE_KEYS = [
+	"invoiceNumber",
+	"orderNumber",
+	"externalId"
+];
+const REFERENCE_HINT$1 = "Add meg a számlaszámot szövegként, vagy pontosan egyet ezek közül: { invoiceNumber }, { orderNumber }, { externalId }.";
+function resolveInvoiceReference(reference) {
+	if (typeof reference === "string") return {
+		kind: "invoiceNumber",
+		value: requireText(reference, `Üres számlaszám. ${REFERENCE_HINT$1}`)
+	};
+	if (typeof reference !== "object" || reference === null) throw validationError(`Érvénytelen bizonylat-hivatkozás. ${REFERENCE_HINT$1}`);
+	const record = reference;
+	const present = REFERENCE_KEYS.filter((key) => record[key] !== void 0);
+	const [kind] = present;
+	if (kind === void 0 || present.length > 1) throw validationError(`Érvénytelen bizonylat-hivatkozás. ${REFERENCE_HINT$1}`);
+	return {
+		kind,
+		value: requireText(record[kind], `Üres ${kind} érték. ${REFERENCE_HINT$1}`)
+	};
+}
+function referenceValue(reference, kind) {
+	return reference.kind === kind ? reference.value : void 0;
+}
+function readNumericHeader(headers, name) {
+	const value = require_create.readHeader(headers, name);
+	if (value === void 0) return void 0;
+	const parsed = Number(value.replace(",", "."));
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function headerSummary(response) {
+	const headers = require_create.readDocumentHeaders(response.headers);
+	return {
+		number: headers.number,
+		netTotal: headers.netTotal,
+		grossTotal: headers.grossTotal,
+		outstanding: readNumericHeader(response.headers, "szlahu_kintlevoseg"),
+		buyerAccountUrl: headers.buyerAccountUrl
+	};
+}
+function decodeResponsePdf(root, response) {
+	const encoded = require_create.childText(root, "pdf");
+	if (encoded === void 0) return void 0;
+	try {
+		return require_binary.base64ToBytes(encoded);
+	} catch (error) {
+		throw new require_errors.SzamlazzError("A válaszban kapott PDF nem érvényes base64.", {
+			category: "unexpected_response",
+			action: response.action,
+			httpStatus: response.status,
+			cause: error
+		});
+	}
+}
+function readInvoiceResultXml(root, response) {
+	const headers = headerSummary(response);
+	return {
+		number: require_create.childText(root, "szamlaszam") ?? headers.number,
+		netTotal: require_create.childNumber(root, "szamlanetto") ?? headers.netTotal,
+		grossTotal: require_create.childNumber(root, "szamlabrutto") ?? headers.grossTotal,
+		outstanding: require_create.childNumber(root, "kintlevoseg") ?? headers.outstanding,
+		buyerAccountUrl: require_create.childText(root, "vevoifiokurl") ?? headers.buyerAccountUrl,
+		pdf: decodeResponsePdf(root, response)
+	};
+}
+const INVOICE_RESULT_ROOT = "xmlszamlavalasz";
+function parseInvoiceResult(response) {
+	require_create.throwIfHeaderError(response);
+	if (response.isPdf) return {
+		...headerSummary(response),
+		pdf: response.body
+	};
+	require_create.throwIfTextError(response);
+	require_create.throwIfHttpError(response);
+	if (require_create.looksLikeXml(response)) {
+		const root = require_create.parseResponseXml(response);
+		require_create.throwIfXmlFailure(root, response);
+		if (root.name !== INVOICE_RESULT_ROOT || require_create.childText(root, "sikeres")?.toLowerCase() !== "true") throw require_create.unexpectedResponse(response, `${INVOICE_RESULT_ROOT} XML választ vártunk.`);
+		return readInvoiceResultXml(root, response);
+	}
+	const headers = headerSummary(response);
+	const done = require_create.parseDoneText(response.text());
+	if (done) return {
+		...headers,
+		number: done.number ?? headers.number
+	};
+	if (headers.number !== void 0) return headers;
+	throw require_create.unexpectedResponse(response);
+}
+//#endregion
+//#region src/invoices/get.ts
+const INVOICE_DOCUMENT_TYPE_CODES = {
+	invoice: "SZ",
+	proforma: "D",
+	advance: "ES",
+	final: "VS",
+	corrective: "HS",
+	reversal: "SS",
+	deliveryNote: "SL"
+};
+function buildGetInvoiceXml(credentials, reference, query = {}) {
+	const resolved = resolveInvoiceReference(reference);
+	return require_create.buildXmlDocument({
+		root: "xmlszamlaxml",
+		namespace: "http://www.szamlazz.hu/xmlszamlaxml",
+		schemaLocation: `${AGENT_XSD_BASE_URL}agentxml/xmlszamlaxml.xsd`,
+		children: [
+			...credentials,
+			require_create.optionalEl("szamlaszam", referenceValue(resolved, "invoiceNumber")),
+			require_create.optionalEl("rendelesSzam", referenceValue(resolved, "orderNumber")),
+			require_create.optionalEl("pdf", query.includePdf),
+			require_create.optionalEl("szamlaKulsoAzon", referenceValue(resolved, "externalId"))
+		]
+	});
+}
+var InvoiceReader = class {
+	response;
+	constructor(response) {
+		this.response = response;
+	}
+	missing(path) {
+		return require_create.unexpectedResponse(this.response, `Hiányzik a(z) <${path}> elem a számla XML-ből.`);
+	}
+	element(parent, name, path) {
+		const child = require_create.findChild(parent, name);
+		if (!child) throw this.missing(path);
+		return child;
+	}
+	text(parent, name, path) {
+		const value = require_create.childText(parent, name);
+		if (value === void 0) throw this.missing(`${path}/${name}`);
+		return value;
+	}
+	number(parent, name, path) {
+		const value = require_create.childNumber(parent, name);
+		if (value === void 0) throw this.missing(`${path}/${name}`);
+		return value;
+	}
+};
+function readAddress(element) {
+	if (!element) return void 0;
+	return {
+		name: require_create.childText(element, "nev"),
+		country: require_create.childText(element, "orszag"),
+		zip: require_create.childText(element, "irsz"),
+		city: require_create.childText(element, "telepules"),
+		address: require_create.childText(element, "cim")
+	};
+}
+function readSeller(root, reader) {
+	const seller = reader.element(root, "szallito", "szallito");
+	const bank = require_create.findChild(seller, "bank");
+	return {
+		id: require_create.childNumber(seller, "id"),
+		name: reader.text(seller, "nev", "szallito"),
+		address: readAddress(require_create.findChild(seller, "cim")),
+		postalAddress: readAddress(require_create.findChild(seller, "postacim")),
+		taxNumber: require_create.childText(seller, "adoszam"),
+		groupTaxNumber: require_create.childText(seller, "csoportazonosito"),
+		euTaxNumber: require_create.childText(seller, "adoszameu"),
+		bank: bank && {
+			name: require_create.childText(bank, "nev"),
+			accountNumber: require_create.childText(bank, "bankszamla")
+		}
+	};
+}
+const DOCUMENT_TYPES_BY_CODE = new Map(Object.entries(INVOICE_DOCUMENT_TYPE_CODES).map(([type, code]) => [code, type]));
+const E_INVOICE_CODES = /* @__PURE__ */ new Set([2, 3]);
+function readHeader(root, reader) {
+	const header = reader.element(root, "alap", "alap");
+	const typeCode = reader.text(header, "tipus", "alap");
+	const appearanceCode = require_create.childNumber(header, "eszamla");
+	return {
+		id: require_create.childNumber(header, "id"),
+		number: reader.text(header, "szamlaszam", "alap"),
+		economicEventId: require_create.childNumber(header, "gazdEsemAzon"),
+		sourceSystem: require_create.childNumber(header, "forras"),
+		registrationNumber: require_create.childText(header, "iktatoszam"),
+		type: DOCUMENT_TYPES_BY_CODE.get(typeCode) ?? "unknown",
+		typeCode,
+		eInvoice: appearanceCode !== void 0 && E_INVOICE_CODES.has(appearanceCode),
+		appearanceCode,
+		referencedInvoiceNumber: require_create.childText(header, "hivszamlaszam"),
+		referencedProformaNumber: require_create.childText(header, "hivdijbekszam"),
+		issueDate: reader.text(header, "kelt", "alap"),
+		fulfillmentDate: require_create.childText(header, "telj"),
+		dueDate: require_create.childText(header, "fizh"),
+		paymentMethod: require_create.childText(header, "fizmod"),
+		unifiedPaymentMethod: require_create.childText(header, "fizmodunified"),
+		cash: require_create.childBoolean(header, "keszpenz"),
+		orderNumber: require_create.childText(header, "rendelesszam"),
+		language: require_create.childText(header, "nyelv"),
+		currency: require_create.childText(header, "devizanem"),
+		exchangeBank: require_create.childText(header, "devizabank"),
+		exchangeRate: require_create.childNumber(header, "devizaarf"),
+		comment: require_create.childText(header, "megjegyzes"),
+		vatType: require_create.childText(header, "afatipus"),
+		cashAccounting: require_create.childBoolean(header, "penzforg"),
+		kata: require_create.childBoolean(header, "kata"),
+		kataLedger: require_create.childBoolean(header, "katafokonyv"),
+		email: require_create.childText(header, "email"),
+		test: require_create.childBoolean(header, "teszt"),
+		reversed: require_create.childBoolean(header, "sztornozott")
+	};
+}
+function readBuyerLedger(element) {
+	if (!element) return void 0;
+	return {
+		ledgerAccount: require_create.childText(element, "vevo"),
+		buyerId: require_create.childText(element, "vevoazon"),
+		bookingDate: require_create.childText(element, "datum"),
+		continuousFulfillment: require_create.childBoolean(element, "folyamatostelj"),
+		settlementPeriodStart: require_create.childText(element, "elszDatTol") ?? require_create.childText(element, "elszdattol"),
+		settlementPeriodEnd: require_create.childText(element, "elszDatIg") ?? require_create.childText(element, "elszdatig")
+	};
+}
+function readBuyer(root, reader) {
+	const buyer = reader.element(root, "vevo", "vevo");
+	return {
+		id: require_create.childNumber(buyer, "id"),
+		name: reader.text(buyer, "nev", "vevo"),
+		identifier: require_create.childText(buyer, "azonosito"),
+		address: readAddress(require_create.findChild(buyer, "cim")),
+		postalAddress: readAddress(require_create.findChild(buyer, "postacim")),
+		email: require_create.childText(buyer, "email"),
+		taxNumber: require_create.childText(buyer, "adoszam"),
+		groupTaxNumber: require_create.childText(buyer, "csoportazonosito"),
+		euTaxNumber: require_create.childText(buyer, "adoszameu"),
+		location: require_create.childNumber(buyer, "lokacio"),
+		privatePerson: require_create.childBoolean(buyer, "privatePersonIndicator"),
+		ledger: readBuyerLedger(require_create.findChild(buyer, "fokonyv"))
+	};
+}
+function readItemLedger(element) {
+	if (!element) return void 0;
+	return {
+		revenueLedgerAccount: require_create.childText(element, "arbevetel"),
+		vatLedgerAccount: require_create.childText(element, "afa"),
+		economicEvent: require_create.childText(element, "gazdasagiesemeny"),
+		vatEconomicEvent: require_create.childText(element, "gazdasagiesemenyafa"),
+		settlementPeriodStart: require_create.childText(element, "elszdattol"),
+		settlementPeriodEnd: require_create.childText(element, "elszdatig")
+	};
+}
+function readItem(item, reader) {
+	const path = "tetelek/tetel";
+	return {
+		name: reader.text(item, "nev", path),
+		identifier: require_create.childText(item, "azonosito"),
+		quantity: reader.number(item, "mennyiseg", path),
+		unit: require_create.childText(item, "mennyisegiegyseg"),
+		netUnitPrice: reader.number(item, "nettoegysegar", path),
+		vat: reader.number(item, "afakulcs", path),
+		vatCode: require_create.childText(item, "afatipus"),
+		netAmount: reader.number(item, "netto", path),
+		marginVatBase: require_create.childNumber(item, "arresafaalap"),
+		vatAmount: reader.number(item, "afa", path),
+		grossAmount: reader.number(item, "brutto", path),
+		comment: require_create.childText(item, "megjegyzes"),
+		position: require_create.childNumber(item, "sztetordering"),
+		ledger: readItemLedger(require_create.findChild(item, "fokonyv"))
+	};
+}
+function readLabels(element) {
+	return require_create.findChildren(element, "cimke").flatMap((label) => {
+		const value = label.text.trim();
+		return value === "" ? [] : [value];
+	});
+}
+function readFinancialItem(item, reader) {
+	const path = "qutetek/qutet";
+	return {
+		name: reader.text(item, "nev", path),
+		vat: reader.number(item, "afakulcs", path),
+		vatCode: require_create.childText(item, "afatipus"),
+		netAmount: reader.number(item, "netto", path),
+		vatAmount: reader.number(item, "afa", path),
+		grossAmount: reader.number(item, "brutto", path),
+		settlementPeriodStart: require_create.childText(item, "elszdattol"),
+		settlementPeriodEnd: require_create.childText(item, "elszdatig"),
+		vatDeduction: require_create.childNumber(item, "afalevon"),
+		labels: readLabels(require_create.findChild(item, "cimkek"))
+	};
+}
+function readTotals(root, reader) {
+	const totals = reader.element(root, "osszegek", "osszegek");
+	const total = reader.element(totals, "totalossz", "osszegek/totalossz");
+	const path = "osszegek/totalossz";
+	return {
+		netAmount: reader.number(total, "netto", path),
+		vatAmount: reader.number(total, "afa", path),
+		grossAmount: reader.number(total, "brutto", path),
+		byVat: require_create.findChildren(totals, "afakulcsossz").map((entry) => ({
+			vat: reader.number(entry, "afakulcs", "osszegek/afakulcsossz"),
+			vatCode: require_create.childText(entry, "afatipus"),
+			netAmount: reader.number(entry, "netto", "osszegek/afakulcsossz"),
+			vatAmount: reader.number(entry, "afa", "osszegek/afakulcsossz"),
+			grossAmount: reader.number(entry, "brutto", "osszegek/afakulcsossz")
+		}))
+	};
+}
+function readPayment(payment, reader) {
+	const path = "kifizetesek/kifizetes";
+	return {
+		date: reader.text(payment, "datum", path),
+		method: reader.text(payment, "jogcim", path),
+		amount: reader.number(payment, "osszeg", path),
+		comment: require_create.childText(payment, "megjegyzes"),
+		bankAccountNumber: require_create.childText(payment, "bankszamlaszam"),
+		bankTransactionId: require_create.childNumber(payment, "banktranzid"),
+		exchangeRate: require_create.childNumber(payment, "devizaarf")
+	};
+}
+function parseInvoiceDetailsXml(root, response) {
+	const reader = new InvoiceReader(response);
+	return {
+		seller: readSeller(root, reader),
+		header: readHeader(root, reader),
+		buyer: readBuyer(root, reader),
+		items: require_create.findChildren(require_create.findChild(root, "tetelek"), "tetel").map((item) => readItem(item, reader)),
+		financialItems: require_create.findChildren(require_create.findChild(root, "qutetek"), "qutet").map((item) => readFinancialItem(item, reader)),
+		labels: readLabels(require_create.findChild(root, "cimkek")),
+		totals: readTotals(root, reader),
+		payments: require_create.findChildren(require_create.findChild(root, "kifizetesek"), "kifizetes").map((payment) => readPayment(payment, reader)),
+		pdf: decodeResponsePdf(root, response)
+	};
+}
+function parseGetInvoiceResponse(response) {
+	require_create.throwIfHeaderError(response);
+	require_create.throwIfTextError(response);
+	require_create.throwIfHttpError(response);
+	const root = require_create.parseResponseXml(response);
+	require_create.throwIfXmlFailure(root, response);
+	if (root.name !== "szamla") throw require_create.unexpectedResponse(response, "A számla XML (<szamla>) helyett más válasz érkezett.");
+	return parseInvoiceDetailsXml(root, response);
+}
+async function getInvoice(ctx, reference, query = {}, options = {}) {
+	const xml = buildGetInvoiceXml(ctx.credentials, reference, query);
+	return ctx.execute({
+		action: "getInvoiceXml",
+		xml,
+		signal: options.signal,
+		safeToRetry: true
+	}, parseGetInvoiceResponse);
+}
+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 require_create.el("kifizetes", [
+		require_create.el("datum", payment.date === void 0 ? require_dates.todayInBudapest() : agentDate(payment.date, "date")),
+		require_create.el("jogcim", requireText(payment.method, `Add meg a(z) ${position}. befizetés módját (method).`)),
+		require_create.el("osszeg", payment.amount),
+		require_create.optionalEl("leiras", optionalText(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 require_create.buildXmlDocument({
+		root: "xmlszamlakifiz",
+		namespace: "http://www.szamlazz.hu/xmlszamlakifiz",
+		schemaLocation: `${AGENT_XSD_BASE_URL}agentkifiz/xmlszamlakifiz.xsd`,
+		children: [require_create.el("beallitasok", [
+			...credentials,
+			require_create.el("szamlaszam", invoiceNumber),
+			require_create.optionalEl("adoszam", optionalText(request.taxNumber)),
+			require_create.el("additiv", request.additive),
+			require_create.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 require_create.buildXmlDocument({
+		root: "xmlszamlapdf",
+		namespace: "http://www.szamlazz.hu/xmlszamlapdf",
+		schemaLocation: `${AGENT_XSD_BASE_URL}agentpdf/xmlszamlapdf.xsd`,
+		children: [
+			...credentials,
+			require_create.optionalEl("szamlaszam", referenceValue(resolved, "invoiceNumber")),
+			require_create.optionalEl("rendelesSzam", referenceValue(resolved, "orderNumber")),
+			require_create.el("valaszVerzio", 2),
+			require_create.optionalEl("szamlaKulsoAzon", referenceValue(resolved, "externalId"))
+		]
+	});
+}
+function parseInvoicePdfResponse(response) {
+	const { pdf, ...rest } = parseInvoiceResult(response);
+	if (pdf === void 0 || pdf.length === 0) throw require_create.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 require_create.buildXmlDocument({
+		root: "xmlszamladbkdel",
+		namespace: "http://www.szamlazz.hu/xmlszamladbkdel",
+		schemaLocation: "http://www.szamlazz.hu/docs/xsds/szamladbkdel/xmlszamladbkdel.xsd",
+		children: [require_create.el("beallitasok", [...credentials]), require_create.el("fejlec", [require_create.optionalEl("szamlaszam", resolved.proformaNumber), require_create.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_create.throwIfHeaderError(response);
+		require_create.throwIfTextError(response);
+		require_create.throwIfHttpError(response);
+		const root = require_create.parseResponseXml(response);
+		require_create.throwIfXmlFailure(root, response);
+		if (!RESPONSE_ROOTS.has(root.name) || require_create.childText(root, "sikeres")?.toLowerCase() !== "true") throw require_create.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.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: ${require_create.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 require_create.buildXmlDocument({
+		root: "xmlszamlast",
+		namespace: "http://www.szamlazz.hu/xmlszamlast",
+		schemaLocation: `${AGENT_XSD_BASE_URL}agentst/xmlszamlast.xsd`,
+		children: [
+			require_create.el("beallitasok", [
+				...credentials,
+				require_create.el("eszamla", options.eInvoice ?? false),
+				require_create.el("szamlaLetoltes", options.downloadPdf ?? true),
+				require_create.el("valaszVerzio", 2),
+				require_create.optionalEl("szamlaKulsoAzon", optionalText(options.externalId))
+			]),
+			require_create.el("fejlec", [
+				require_create.el("szamlaszam", invoiceNumber),
+				require_create.optionalEl("keltDatum", optionalAgentDate(options.issueDate, "issueDate")),
+				require_create.optionalEl("teljesitesDatum", optionalAgentDate(options.fulfillmentDate, "fulfillmentDate")),
+				require_create.optionalEl("megjegyzes", optionalText(options.comment)),
+				require_create.el("tipus", "SS"),
+				require_create.optionalEl("szamlaSablon", validateTemplate(options.template))
+			]),
+			require_create.optionalEl("elado", [
+				require_create.optionalEl("emailReplyto", optionalText(email?.replyTo)),
+				require_create.optionalEl("emailTargy", optionalText(email?.subject)),
+				require_create.optionalEl("emailSzoveg", optionalText(email?.text))
+			]),
+			require_create.optionalEl("vevo", [
+				require_create.optionalEl("email", optionalText(buyer?.email)),
+				require_create.optionalEl("adoszam", optionalText(buyer?.taxNumber)),
+				require_create.optionalEl("adoszamEU", optionalText(buyer?.euTaxNumber))
+			])
+		]
+	});
+}
+function parseReverseInvoiceResponse(response, originalInvoiceNumber) {
+	const result = parseInvoiceResult(response);
+	if (result.number === void 0) throw require_create.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_create.buildXmlDocument({
+		root: "xmlnyugtaget",
+		namespace: GET_RECEIPT_NAMESPACE,
+		schemaLocation: `${require_create.RECEIPT_XSD_BASE_URL}nyugtaget/xmlnyugtaget.xsd`,
+		children: [require_create.el("beallitasok", [...credentials, require_create.el("pdfLetoltes", normalized.downloadPdf ?? true)]), require_create.el("fejlec", [
+			require_create.optionalEl("nyugtaszam", receiptNumber),
+			require_create.optionalEl("rendelesSzam", orderNumber),
+			require_create.optionalEl("hivasAzonosito", require_create.optionalText(normalized.callId)),
+			require_create.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_create.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_create.buildXmlDocument({
+		root: "xmlnyugtast",
+		namespace: REVERSE_RECEIPT_NAMESPACE,
+		schemaLocation: `${require_create.RECEIPT_XSD_BASE_URL}nyugtast/xmlnyugtast.xsd`,
+		children: [require_create.el("beallitasok", [...credentials, require_create.el("pdfLetoltes", normalized.downloadPdf ?? true)]), require_create.el("fejlec", [
+			require_create.el("nyugtaszam", require_create.requireReceiptNumber(normalized.receiptNumber)),
+			require_create.optionalEl("pdfSablon", require_create.validateTemplate(normalized.template)),
+			require_create.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_create.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_create.buildXmlDocument({
+		root: "xmlnyugtasend",
+		namespace: SEND_RECEIPT_NAMESPACE,
+		schemaLocation: `${require_create.RECEIPT_XSD_BASE_URL}nyugtasend/xmlnyugtasend.xsd`,
+		children: [
+			require_create.el("beallitasok", credentials),
+			require_create.el("fejlec", [require_create.el("nyugtaszam", receiptNumber)]),
+			require_create.el("emailKuldes", [
+				require_create.el("email", emails.join(",")),
+				require_create.optionalEl("emailReplyto", replyTo),
+				require_create.el("emailTargy", require_create.optionalText(input.subject) ?? `Nyugta ${receiptNumber}`),
+				require_create.optionalEl("emailSzoveg", input.text?.trim() ? input.text : void 0)
+			])
+		]
+	});
+}
+function parseSendReceiptResponse(response) {
+	require_create.throwIfHeaderError(response);
+	require_create.throwIfTextError(response);
+	if (!require_create.looksLikeXml(response)) {
+		require_create.throwIfHttpError(response);
+		if (require_create.parseDoneText(response.text())) return;
+		throw require_create.unexpectedResponse(response, "XML választ vártunk a nyugta kiküldésére.");
+	}
+	const root = require_create.parseResponseXml(response);
+	require_create.throwIfXmlFailure(root, response);
+	if (require_create.childBoolean(root, "sikeres") !== true) {
+		require_create.throwIfHttpError(response);
+		throw require_create.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_create.childText(element, "countryCode"),
+		region: require_create.childText(element, "region"),
+		postalCode: require_create.childText(element, "postalCode"),
+		city: require_create.childText(element, "city"),
+		streetName: require_create.childText(element, "streetName"),
+		publicPlaceCategory: require_create.childText(element, "publicPlaceCategory"),
+		number: require_create.childText(element, "number"),
+		building: require_create.childText(element, "building"),
+		staircase: require_create.childText(element, "staircase"),
+		floor: require_create.childText(element, "floor"),
+		door: require_create.childText(element, "door"),
+		lotNumber: require_create.childText(element, "lotNumber")
+	};
+}
+function parseTaxpayerAddress(item) {
+	const raw = readDetailedAddress(require_create.findChild(item, "taxpayerAddress"));
+	const address = {
+		type: require_create.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_create.buildXmlDocument({
+		root: "xmltaxpayer",
+		namespace: TAXPAYER_NAMESPACE,
+		schemaLocation: TAXPAYER_SCHEMA_LOCATION,
+		children: [require_create.el("beallitasok", credentials), require_create.el("torzsszam", toTaxpayerId(taxNumber))]
+	});
+}
+function throwIfNavError(root, response) {
+	const result = require_create.findChild(root, "result");
+	if (require_create.childText(result, "funcCode")?.toUpperCase() !== "ERROR") return;
+	const errorCode = require_create.childText(result, "errorCode");
+	const code = require_errors.parseErrorCode(errorCode);
+	const message = require_create.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_create.findChild(data, "taxNumberDetail");
+	const taxpayerId = require_create.childText(detail, "taxpayerId");
+	if (taxpayerId === void 0) return void 0;
+	const vatCode = require_create.childText(detail, "vatCode");
+	const countyCode = require_create.childText(detail, "countyCode");
+	return {
+		taxpayerId,
+		vatCode,
+		countyCode,
+		formatted: vatCode !== void 0 && countyCode !== void 0 ? `${taxpayerId}-${vatCode}-${countyCode}` : void 0
+	};
+}
+function readAddresses(data) {
+	return require_create.findChildren(require_create.findChild(data, "taxpayerAddressList"), "taxpayerAddressItem").map(parseTaxpayerAddress);
+}
+function readRequestId(root) {
+	const requestId = require_create.childText(require_create.findChild(root, "header"), "requestId");
+	return requestId === "-" ? void 0 : requestId;
+}
+function parseQueryTaxpayerResponse(response) {
+	require_create.throwIfAnyError(response);
+	const root = require_create.parseResponseXml(response);
+	require_create.throwIfXmlFailure(root, response);
+	if (root.name !== "QueryTaxpayerResponse") throw require_create.unexpectedResponse(response, "QueryTaxpayerResponse XML választ vártunk.");
+	throwIfNavError(root, response);
+	const requestId = readRequestId(root);
+	const infoDate = require_create.childText(root, "infoDate");
+	const data = require_create.findChild(root, "taxpayerData");
+	const validity = require_create.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_create.childText(data, "taxpayerName"),
+		shortName: require_create.childText(data, "taxpayerShortName"),
+		taxNumber: readTaxNumber(data),
+		address: addresses.find((address) => address.type === "HQ") ?? addresses[0],
+		addresses,
+		incorporation: require_create.childText(data, "incorporation"),
+		vatGroupMembership: require_create.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 (require_errors.isSzamlazzError(error) && (error.isNotFound || error.code === 7)) return null;
+		throw error;
+	}
+}
+function createInvoicesApi(ctx, defaults) {
+	return {
+		create: (input, options) => createInvoice(ctx, defaults, input, options),
+		preview: (input, options) => previewInvoice(ctx, defaults, input, options),
+		reverse: (input, options) => reverseInvoice(ctx, input, options),
+		registerPayment: (input, options) => registerPayment(ctx, input, options),
+		clearPayments: (input, options) => clearPayments(ctx, input, options),
+		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)
+	};
+}
+function createReceiptsApi(ctx, defaults) {
+	return {
+		create: (input, options) => require_create.createReceipt(ctx, defaults, input, options),
+		reverse: (input, options) => reverseReceipt(ctx, input, options),
+		get: (input, options) => getReceipt(ctx, input, options),
+		find: (input, options) => nullIfNotFound(getReceipt(ctx, input, options)),
+		send: (input, options) => sendReceipt(ctx, input, options)
+	};
+}
+function createKassza(options = {}) {
+	const ctx = createAgentContext(options);
+	return {
+		invoices: createInvoicesApi(ctx, options.defaults?.invoice ?? {}),
+		receipts: createReceiptsApi(ctx, options.defaults?.receipt ?? {}),
+		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 (!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()
+	};
+}
+//#endregion
+exports.AGENT_ACTIONS = require_create.AGENT_ACTIONS;
+exports.AGENT_ERROR_CODES = require_errors.AGENT_ERROR_CODES;
+exports.MAX_INVOICE_ATTACHMENTS = require_create.MAX_INVOICE_ATTACHMENTS;
+exports.SZAMLAZZ_AGENT_URL = require_create.SZAMLAZZ_AGENT_URL;
+exports.SzamlazzError = require_errors.SzamlazzError;
+exports.addBudapestDays = require_dates.addBudapestDays;
+exports.bytesToBase64 = require_binary.bytesToBase64;
+exports.createKassza = createKassza;
+exports.isSzamlazzError = require_errors.isSzamlazzError;
+exports.memoryCookieStore = require_session.memoryCookieStore;
+exports.toBudapestDate = require_dates.toBudapestDate;
+exports.todayInBudapest = require_dates.todayInBudapest;