kassza 0.10.0 → 0.12.0

package/dist/delegation/index.cjs

@@ -0,0 +1,395 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("../errors-DxeuTslP.cjs");
+const require_client = require("../client-CsmGIFRS.cjs");
+const require_issue = require("../issue-BsyYdrIG.cjs");
+const require_dates = require("../dates-CPgBodkP.cjs");
+const require_tax_number = require("../tax-number-BYFkBp4A.cjs");
+//#region src/delegation/connect.ts
+const CONNECT_PRINCIPAL_NAMESPACE = "http://www.szamlazz.hu/xmlcegmb";
+const CONNECT_PRINCIPAL_SCHEMA_LOCATION = "http://www.szamlazz.hu/docs/xsds/agentmb/xmlcegmb.xsd";
+const DELEGATE_PREFIX_PATTERN = /^[A-Z0-9]{1,5}$/;
+const DELEGATE_PASSWORD_MIN_LENGTH = 8;
+const DELEGATE_PASSWORD_MAX_LENGTH = 128;
+const AGENT_RESPONSE_HEADER = "XML_AGENT_RESPONSE";
+const AGENT_RESPONSE_TEXT = /xmlagentresponse\s*=\s*([^\r\n]*)/i;
+const strictUtf8 = new TextDecoder("utf-8", { fatal: true });
+function validation(message, hint) {
+	return new require_errors.SzamlazzError(message, {
+		category: "validation",
+		action: "connectPrincipal",
+		hint
+	});
+}
+function required(value, label) {
+	const trimmed = value?.trim();
+	if (!trimmed) throw validation(`A(z) ${label} megadása kötelező.`);
+	return trimmed;
+}
+function optionalText(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function normalizeDelegateTaxNumber(value) {
+	const parsed = require_tax_number.parseHungarianTaxNumber(value);
+	if (!parsed) throw validation(`A megbízó adószáma (${value}) nem érvényes 11 jegyű magyar adószám.`, "A Számlázz.hu a teljes, 13 karakteres adószám (12345678-1-23) pontos egyezésével keresi a meglévő fiókot; elgépelt adószámmal új, felesleges fiók jönne létre.");
+	return parsed.formatted;
+}
+function assertDelegatePrefix(value, label = "számlaszám-előtag") {
+	const prefix = required(value, label);
+	if (!DELEGATE_PREFIX_PATTERN.test(prefix)) throw validation(`A(z) ${label} (${prefix}) csak nagybetűt és számot tartalmazhat, és legfeljebb 5 karakter lehet (337).`);
+	return prefix;
+}
+function requiredEmail(value, label) {
+	const email = required(value, label);
+	if (!require_tax_number.isValidEmail(email)) throw validation(`A(z) ${label} (${email}) nem érvényes e-mail cím.`);
+	return email;
+}
+function optionalEmail(value, label) {
+	const email = optionalText(value);
+	if (email !== void 0 && !require_tax_number.isValidEmail(email)) throw validation(`A(z) ${label} (${email}) nem érvényes e-mail cím.`);
+	return email;
+}
+function assertPassword(password) {
+	if (typeof password !== "string" || password.length < 8) throw validation(`A dedikált felhasználó jelszava legalább 8 karakter legyen (506).`);
+	if (password.length > 128) throw validation(`A dedikált felhasználó jelszava legfeljebb 128 karakter lehet (507).`);
+}
+function optionalDate(value, label) {
+	if (value === void 0) return void 0;
+	try {
+		return require_dates.toAgentDate(value);
+	} catch (error) {
+		throw validation(`A(z) ${label} nem érvényes dátum: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function assertPeriod(from, to, label) {
+	if (to !== void 0 && from === void 0) throw validation(`A(z) ${label} záródátumához kezdődátum is kell.`);
+	if (from !== void 0 && to !== void 0 && to < from) throw validation(`A(z) ${label} záródátuma nem lehet korábbi a kezdődátumnál.`);
+}
+function normalizeInput(input) {
+	const { principal, user } = input;
+	required(principal?.name, "megbízó cégneve");
+	const taxNumber = normalizeDelegateTaxNumber(required(principal.taxNumber, "megbízó adószáma"));
+	const invoicePrefix = assertDelegatePrefix(principal.invoicePrefix);
+	required(principal.zip, "székhely irányítószáma");
+	required(principal.city, "székhely települése");
+	required(principal.address, "székhely címe");
+	requiredEmail(principal.email, "megbízó e-mail címe");
+	optionalEmail(principal.replyToEmail, "válaszcím (replyToEmail)");
+	if (principal.postalAddress) {
+		required(principal.postalAddress.zip, "postázási irányítószám");
+		required(principal.postalAddress.city, "postázási település");
+		required(principal.postalAddress.address, "postázási cím");
+	}
+	const userEmail = requiredEmail(user?.email, "dedikált felhasználó e-mail címe");
+	assertPassword(user.password);
+	required(user.firstName, "dedikált felhasználó keresztneve");
+	const cashAccountingFrom = optionalDate(principal.cashAccountingFrom, "pénzforgalmi időszak kezdete");
+	const cashAccountingTo = optionalDate(principal.cashAccountingTo, "pénzforgalmi időszak vége");
+	const kataFrom = optionalDate(principal.kataFrom, "KATA időszak kezdete");
+	const kataTo = optionalDate(principal.kataTo, "KATA időszak vége");
+	assertPeriod(cashAccountingFrom, cashAccountingTo, "pénzforgalmi időszak");
+	assertPeriod(kataFrom, kataTo, "KATA időszak");
+	return {
+		taxNumber,
+		invoicePrefix,
+		principal,
+		user,
+		userEmail,
+		cashAccountingFrom,
+		cashAccountingTo,
+		kataFrom,
+		kataTo
+	};
+}
+function loginNodes(credentials) {
+	const value = (name) => {
+		const node = credentials.find((candidate) => candidate.name === name);
+		return node === void 0 ? void 0 : String(node.content);
+	};
+	const agentKey = value("szamlaagentkulcs");
+	if (agentKey !== void 0) return [require_issue.el("szamlaagentkulcs", agentKey)];
+	const username = value("felhasznalo");
+	const password = value("jelszo");
+	if (username === void 0 || password === void 0) throw new require_errors.SzamlazzError("A megbízotti fiók azonosításához Agent kulcs vagy felhasználónév és jelszó kell.", {
+		category: "configuration",
+		action: "connectPrincipal"
+	});
+	return [require_issue.el("loginname", username), require_issue.el("password", password)];
+}
+function principalNodes(input) {
+	const { principal } = input;
+	return require_issue.el("cegMb", [
+		require_issue.el("cegcompanyname", principal.name.trim()),
+		require_issue.el("cegtaxnumber", input.taxNumber),
+		require_issue.el("cegszamlaszamelotag", input.invoicePrefix),
+		require_issue.el("cegirsz", principal.zip.trim()),
+		require_issue.el("cegcity", principal.city.trim()),
+		require_issue.el("cegaddr", principal.address.trim()),
+		require_issue.optionalEl("cegpostirsz", optionalText(principal.postalAddress?.zip)),
+		require_issue.optionalEl("cegpostcity", optionalText(principal.postalAddress?.city)),
+		require_issue.optionalEl("cegpostaddr", optionalText(principal.postalAddress?.address)),
+		require_issue.el("cegbank", optionalText(principal.bankName) ?? ""),
+		require_issue.el("cegbankaccount", optionalText(principal.bankAccount) ?? ""),
+		require_issue.el("cegemail", principal.email.trim()),
+		require_issue.el("cegemailreplyto", optionalText(principal.replyToEmail) ?? ""),
+		require_issue.optionalEl("cegpenzforgdattol", input.cashAccountingFrom),
+		require_issue.optionalEl("cegpenzforgdatig", input.cashAccountingTo),
+		require_issue.optionalEl("cegkatadattol", input.kataFrom),
+		require_issue.optionalEl("cegkatadatig", input.kataTo)
+	]);
+}
+function userNodes(input) {
+	return require_issue.el("usrMb", [
+		require_issue.el("usremail", input.userEmail),
+		require_issue.el("usrpassword", input.user.password),
+		require_issue.optionalEl("usrvezeteknev", optionalText(input.user.lastName)),
+		require_issue.el("usrkeresztnev", input.user.firstName.trim())
+	]);
+}
+function buildXml(credentials, input) {
+	return require_issue.buildXmlDocument({
+		root: "XmlCegMb",
+		namespace: CONNECT_PRINCIPAL_NAMESPACE,
+		schemaLocation: CONNECT_PRINCIPAL_SCHEMA_LOCATION,
+		children: [
+			require_issue.el("login", loginNodes(credentials)),
+			principalNodes(input),
+			userNodes(input)
+		]
+	});
+}
+function buildConnectPrincipalXml(credentials, input) {
+	return buildXml(credentials, normalizeInput(input));
+}
+function normalizeMessage(message) {
+	return message.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/\s+/g, " ").trim();
+}
+function connectPrincipalStatus(message) {
+	const normalized = normalizeMessage(message);
+	if (/^done(?:;|$)/.test(normalized)) return "account-created";
+	if (normalized.includes("nincs fiokgazdaja")) return "owner-invite-resent";
+	if (normalized.includes("csatlakozasi kerelem") && normalized.includes("ujrakuld")) return "join-request-resent";
+	if (normalized.includes("csatlakozasi kerelmet kuldtunk")) return "join-request-sent";
+	return "unknown";
+}
+const LATIN1_HIGH_START = 128;
+const LATIN1_END = 255;
+function looksLikeLatin1Utf8(value) {
+	let hasHighByte = false;
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code > LATIN1_END) return false;
+		if (code >= LATIN1_HIGH_START) hasHighByte = true;
+	}
+	return hasHighByte;
+}
+function repairMojibake(value) {
+	if (!looksLikeLatin1Utf8(value)) return value;
+	try {
+		return strictUtf8.decode(Uint8Array.from(value, (char) => char.charCodeAt(0)));
+	} catch {
+		return value;
+	}
+}
+function agentResponseMessage(response) {
+	const header = require_issue.readHeader(response.headers, AGENT_RESPONSE_HEADER, true);
+	if (header !== void 0) return repairMojibake(header);
+	const match = AGENT_RESPONSE_TEXT.exec(response.text());
+	const body = match?.[1] ? require_issue.decodeHeaderValue(match[1]).trim() : void 0;
+	return body ? body : void 0;
+}
+function parseConnectPrincipalResponse(response) {
+	require_issue.throwIfAnyError(response);
+	const message = agentResponseMessage(response);
+	if (message === void 0) throw require_issue.unexpectedResponse(response, "Hiányzik az XML_AGENT_RESPONSE válasz.");
+	return {
+		status: connectPrincipalStatus(message),
+		message
+	};
+}
+async function assertActiveTaxpayer(ctx, taxNumber, options) {
+	if (!(await require_client.queryTaxpayer(ctx, taxNumber, options)).valid) throw validation(`A(z) ${taxNumber} adószám a NAV szerint nem érvényes, ezért nem küldöm el a csatlakozási kérelmet.`, "Ellenőrizd a megbízó adószámát; elgépelt adószámmal új, felesleges fiók jönne létre.");
+}
+async function connectPrincipalWith(ctx, input, options = {}) {
+	const normalized = normalizeInput(input);
+	const xml = buildXml(ctx.credentials, normalized);
+	const requestOptions = { signal: options.signal };
+	if (options.verifyTaxNumber === true) await assertActiveTaxpayer(ctx, normalized.taxNumber, requestOptions);
+	return {
+		...await ctx.execute({
+			action: "connectPrincipal",
+			xml,
+			signal: options.signal
+		}, parseConnectPrincipalResponse),
+		taxNumber: normalized.taxNumber,
+		invoicePrefix: normalized.invoicePrefix,
+		userEmail: normalized.userEmail
+	};
+}
+async function connectPrincipal(input, options = {}) {
+	const { signal, verifyTaxNumber, ...szamlazzOptions } = options;
+	return connectPrincipalWith(require_client.createAgentContext(szamlazzOptions), input, {
+		signal,
+		verifyTaxNumber
+	});
+}
+//#endregion
+//#region src/delegation/pool.ts
+const DEFAULT_POOL_SIZE = 100;
+const RECEIPT_PREFIX_PATTERN = /^[A-Z0-9]+$/;
+function configuration$1(message, hint) {
+	return new require_errors.SzamlazzError(message, {
+		category: "configuration",
+		hint
+	});
+}
+function delegatePrefix(value) {
+	const prefix = value?.trim();
+	if (!prefix || !DELEGATE_PREFIX_PATTERN.test(prefix)) throw configuration$1(`A megbízotti számlaszám-előtag (${prefix ?? ""}) csak nagybetűt és számot tartalmazhat, és legfeljebb 5 karakter lehet.`, "A csatlakozáskor egyeztetett előtagot add meg; ezt a kassza minden számlában elküldi, így nem fut 357-es hibára egy második számlatömb után sem.");
+	return prefix;
+}
+function receiptPrefix(value) {
+	if (value === void 0) return void 0;
+	const prefix = value.trim();
+	if (!RECEIPT_PREFIX_PATTERN.test(prefix)) throw configuration$1(`A megbízotti nyugtaelőtag (${prefix}) csak nagybetűt és számot tartalmazhat.`);
+	return prefix;
+}
+function createDelegateKassza(options) {
+	const { username, password, invoicePrefix, receiptPrefix: receipt, defaults, ...rest } = options;
+	if (options.agentKey !== void 0) throw configuration$1("Megbízotti kiállításhoz nem használható Agent kulcs: a kulcs a fiókhoz tartozik, így a bizonylat a megbízó saját neve alatt készülne.", "Add meg a csatlakozáskor létrehozott dedikált (usrMb) felhasználó felhasználónevét és jelszavát.");
+	if (!username?.trim() || !password) throw configuration$1("Add meg a dedikált (usrMb) felhasználó felhasználónevét és jelszavát.");
+	const prefix = delegatePrefix(invoicePrefix);
+	const receiptDefaultPrefix = receiptPrefix(receipt);
+	const receiptDefaults = receiptDefaultPrefix === void 0 ? defaults?.receipt : {
+		...defaults?.receipt,
+		prefix: receiptDefaultPrefix
+	};
+	return require_client.createKassza({
+		...rest,
+		username: username.trim(),
+		password,
+		defaults: {
+			invoice: {
+				...defaults?.invoice,
+				prefix
+			},
+			...receiptDefaults === void 0 ? {} : { receipt: receiptDefaults }
+		}
+	});
+}
+function poolSize(value) {
+	if (value === void 0) return 100;
+	if (!Number.isInteger(value) || value < 1) throw configuration$1(`A maxClients értéke legalább 1 egész szám legyen, kapott: ${value}`);
+	return value;
+}
+function createKasszaPool(options) {
+	const { resolve, maxClients, ...shared } = options;
+	if (typeof resolve !== "function") throw configuration$1("A kassza poolhoz add meg a resolve függvényt.");
+	const limit = poolSize(maxClients);
+	const clients = /* @__PURE__ */ new Map();
+	async function create(principalId) {
+		const credentials = await resolve(principalId);
+		if (!credentials) throw configuration$1(`Ismeretlen megbízó: ${principalId}.`);
+		return createDelegateKassza({
+			...shared,
+			...credentials
+		});
+	}
+	function evict() {
+		while (clients.size > limit) {
+			const oldest = clients.keys().next();
+			if (oldest.done) return;
+			clients.delete(oldest.value);
+		}
+	}
+	return {
+		get(principalId) {
+			const id = typeof principalId === "string" ? principalId.trim() : "";
+			if (!id) return Promise.reject(configuration$1("Add meg a megbízó azonosítóját."));
+			const existing = clients.get(id);
+			if (existing) {
+				clients.delete(id);
+				clients.set(id, existing);
+				return existing;
+			}
+			const created = create(id);
+			clients.set(id, created);
+			created.catch(() => {
+				if (clients.get(id) === created) clients.delete(id);
+			});
+			evict();
+			return created;
+		},
+		forget(principalId) {
+			clients.delete(principalId.trim());
+		},
+		clear() {
+			clients.clear();
+		},
+		get size() {
+			return clients.size;
+		}
+	};
+}
+//#endregion
+//#region src/delegation/probe.ts
+const DELEGATION_PROBE_INVOICE_NUMBER = "KASSZA-DELEGATION-PROBE-0";
+const MESSAGES = {
+	active: "A megbízotti kapcsolat él: a dedikált felhasználó be tud lépni a megbízó fiókjába.",
+	"awaiting-approval": "A belépés sikertelen (3): a megbízó még nem fogadta el a csatlakozási kérelmet, vagy hibás a felhasználónév vagy a jelszó.",
+	"awaiting-owner-registration": "A megbízó még nem vette birtokba az új fiókot (250). A Számlázz.hu minden ilyen hívásnál újraküldi neki a fiókgazdai meghívót, ezért ne ellenőrizd ciklusban.",
+	"multi-account-user": "A dedikált felhasználó több fiókhoz fér hozzá (164), így Számla Agenttel nem használható. Vedd le a hozzáférését a többi fiókról, vagy használj új dedikált felhasználót."
+};
+const STATES_BY_CODE = /* @__PURE__ */ new Map([
+	[3, "awaiting-approval"],
+	[250, "awaiting-owner-registration"],
+	[164, "multi-account-user"]
+]);
+function configuration(message) {
+	return new require_errors.SzamlazzError(message, { category: "configuration" });
+}
+async function probeDelegation(options) {
+	const { signal, agentKey, ...rest } = options;
+	if (agentKey !== void 0) throw configuration("A megbízotti kapcsolat ellenőrzéséhez a dedikált felhasználó felhasználónevét és jelszavát add meg. Az Agent kulcs a fiókhoz tartozik, nem hordozza a megbízotti kapcsolatot.");
+	if (!rest.username?.trim() || !rest.password) throw configuration("Add meg a dedikált (usrMb) felhasználó felhasználónevét és jelszavát.");
+	const ctx = require_client.createAgentContext(rest);
+	try {
+		await require_client.getInvoicePdf(ctx, DELEGATION_PROBE_INVOICE_NUMBER, { signal });
+		return {
+			state: "active",
+			message: MESSAGES.active
+		};
+	} catch (error) {
+		if (!require_errors.isSzamlazzError(error)) throw error;
+		if (error.isNotFound || error.code === 7) return {
+			state: "active",
+			message: MESSAGES.active
+		};
+		const state = error.code === void 0 ? void 0 : STATES_BY_CODE.get(error.code);
+		if (state === void 0) throw error;
+		return {
+			state,
+			message: MESSAGES[state],
+			error
+		};
+	}
+}
+//#endregion
+exports.CONNECT_PRINCIPAL_NAMESPACE = CONNECT_PRINCIPAL_NAMESPACE;
+exports.CONNECT_PRINCIPAL_SCHEMA_LOCATION = CONNECT_PRINCIPAL_SCHEMA_LOCATION;
+exports.DEFAULT_POOL_SIZE = DEFAULT_POOL_SIZE;
+exports.DELEGATE_PASSWORD_MAX_LENGTH = DELEGATE_PASSWORD_MAX_LENGTH;
+exports.DELEGATE_PASSWORD_MIN_LENGTH = DELEGATE_PASSWORD_MIN_LENGTH;
+exports.DELEGATE_PREFIX_PATTERN = DELEGATE_PREFIX_PATTERN;
+exports.DELEGATION_PROBE_INVOICE_NUMBER = DELEGATION_PROBE_INVOICE_NUMBER;
+exports.assertDelegatePrefix = assertDelegatePrefix;
+exports.buildConnectPrincipalXml = buildConnectPrincipalXml;
+exports.connectPrincipal = connectPrincipal;
+exports.connectPrincipalStatus = connectPrincipalStatus;
+exports.connectPrincipalWith = connectPrincipalWith;
+exports.createDelegateKassza = createDelegateKassza;
+exports.createKasszaPool = createKasszaPool;
+exports.normalizeDelegateTaxNumber = normalizeDelegateTaxNumber;
+exports.parseConnectPrincipalResponse = parseConnectPrincipalResponse;
+exports.probeDelegation = probeDelegation;
+exports.suggestedPrefix = require_errors.suggestedPrefix;

package/dist/delegation/index.d.cts

@@ -0,0 +1,99 @@
+import { J as AgentContext, Kt as suggestedPrefix, Q as RequestOptions, Ut as SzamlazzError, et as SzamlazzOptions, ht as AgentResponse, i as KasszaOptions, mt as XmlNode, n as Kassza, r as KasszaDefaults } from "../client-DvWZoX_E.cjs";
+import { t as DateInput } from "../dates-9zvESP0i.cjs";
+//#region src/delegation/connect.d.ts
+export declare const CONNECT_PRINCIPAL_NAMESPACE = "http://www.szamlazz.hu/xmlcegmb";
+export declare const CONNECT_PRINCIPAL_SCHEMA_LOCATION = "http://www.szamlazz.hu/docs/xsds/agentmb/xmlcegmb.xsd";
+export declare const DELEGATE_PREFIX_PATTERN: RegExp;
+export declare const DELEGATE_PASSWORD_MIN_LENGTH = 8;
+export declare const DELEGATE_PASSWORD_MAX_LENGTH = 128;
+interface PrincipalAddress {
+  readonly zip: string;
+  readonly city: string;
+  readonly address: string;
+}
+interface PrincipalCompany {
+  readonly name: string;
+  readonly taxNumber: string;
+  readonly invoicePrefix: string;
+  readonly zip: string;
+  readonly city: string;
+  readonly address: string;
+  readonly postalAddress?: PrincipalAddress | undefined;
+  readonly bankName?: string | undefined;
+  readonly bankAccount?: string | undefined;
+  readonly email: string;
+  readonly replyToEmail?: string | undefined;
+  readonly cashAccountingFrom?: DateInput | undefined;
+  readonly cashAccountingTo?: DateInput | undefined;
+  readonly kataFrom?: DateInput | undefined;
+  readonly kataTo?: DateInput | undefined;
+}
+interface DelegateUser {
+  readonly email: string;
+  readonly password: string;
+  readonly firstName: string;
+  readonly lastName?: string | undefined;
+}
+interface ConnectPrincipalInput {
+  readonly principal: PrincipalCompany;
+  readonly user: DelegateUser;
+}
+type ConnectPrincipalStatus = "account-created" | "owner-invite-resent" | "join-request-resent" | "join-request-sent" | "unknown";
+interface ConnectPrincipalResponse {
+  readonly status: ConnectPrincipalStatus;
+  readonly message: string;
+}
+interface ConnectPrincipalResult extends ConnectPrincipalResponse {
+  readonly taxNumber: string;
+  readonly invoicePrefix: string;
+  readonly userEmail: string;
+}
+interface ConnectPrincipalOptions extends SzamlazzOptions, RequestOptions {
+  readonly verifyTaxNumber?: boolean | undefined;
+}
+export declare function normalizeDelegateTaxNumber(value: string): string;
+export declare function assertDelegatePrefix(value: string, label?: string): string;
+export declare function buildConnectPrincipalXml(credentials: readonly XmlNode[], input: ConnectPrincipalInput): string;
+export declare function connectPrincipalStatus(message: string): ConnectPrincipalStatus;
+export declare function parseConnectPrincipalResponse(response: AgentResponse): ConnectPrincipalResponse;
+export declare function connectPrincipalWith(ctx: AgentContext, input: ConnectPrincipalInput, options?: RequestOptions & {
+  readonly verifyTaxNumber?: boolean | undefined;
+}): Promise<ConnectPrincipalResult>;
+export declare function connectPrincipal(input: ConnectPrincipalInput, options?: ConnectPrincipalOptions): Promise<ConnectPrincipalResult>;
+//#endregion
+//#region src/delegation/pool.d.ts
+export declare const DEFAULT_POOL_SIZE = 100;
+interface DelegateCredentials {
+  readonly username: string;
+  readonly password: string;
+  readonly invoicePrefix: string;
+  readonly receiptPrefix?: string | undefined;
+  readonly defaults?: KasszaDefaults | undefined;
+}
+interface DelegateKasszaOptions extends Omit<KasszaOptions, "agentKey" | "username" | "password" | "defaults">, DelegateCredentials {}
+type DelegateResolver = (principalId: string) => DelegateCredentials | undefined | Promise<DelegateCredentials | undefined>;
+interface KasszaPoolOptions extends Omit<KasszaOptions, "agentKey" | "username" | "password" | "defaults"> {
+  readonly resolve: DelegateResolver;
+  readonly maxClients?: number | undefined;
+}
+interface KasszaPool {
+  get(principalId: string): Promise<Kassza>;
+  forget(principalId: string): void;
+  clear(): void;
+  readonly size: number;
+}
+export declare function createDelegateKassza(options: DelegateKasszaOptions): Kassza;
+export declare function createKasszaPool(options: KasszaPoolOptions): KasszaPool;
+//#endregion
+//#region src/delegation/probe.d.ts
+type DelegationState = "active" | "awaiting-approval" | "awaiting-owner-registration" | "multi-account-user";
+interface DelegationProbeResult {
+  readonly state: DelegationState;
+  readonly message: string;
+  readonly error?: SzamlazzError | undefined;
+}
+interface ProbeDelegationOptions extends SzamlazzOptions, RequestOptions {}
+export declare const DELEGATION_PROBE_INVOICE_NUMBER = "KASSZA-DELEGATION-PROBE-0";
+export declare function probeDelegation(options: ProbeDelegationOptions): Promise<DelegationProbeResult>;
+//#endregion
+export { type ConnectPrincipalInput, type ConnectPrincipalOptions, type ConnectPrincipalResponse, type ConnectPrincipalResult, type ConnectPrincipalStatus, type DelegateCredentials, type DelegateKasszaOptions, type DelegateResolver, type DelegateUser, type DelegationProbeResult, type DelegationState, type KasszaPool, type KasszaPoolOptions, type PrincipalAddress, type PrincipalCompany, type ProbeDelegationOptions, suggestedPrefix };

package/dist/delegation/index.d.ts

@@ -0,0 +1,99 @@
+import { J as AgentContext, Kt as suggestedPrefix, Q as RequestOptions, Ut as SzamlazzError, et as SzamlazzOptions, ht as AgentResponse, i as KasszaOptions, mt as XmlNode, n as Kassza, r as KasszaDefaults } from "../client-CickRRFr.js";
+import { t as DateInput } from "../dates-9zvESP0i.js";
+//#region src/delegation/connect.d.ts
+export declare const CONNECT_PRINCIPAL_NAMESPACE = "http://www.szamlazz.hu/xmlcegmb";
+export declare const CONNECT_PRINCIPAL_SCHEMA_LOCATION = "http://www.szamlazz.hu/docs/xsds/agentmb/xmlcegmb.xsd";
+export declare const DELEGATE_PREFIX_PATTERN: RegExp;
+export declare const DELEGATE_PASSWORD_MIN_LENGTH = 8;
+export declare const DELEGATE_PASSWORD_MAX_LENGTH = 128;
+interface PrincipalAddress {
+  readonly zip: string;
+  readonly city: string;
+  readonly address: string;
+}
+interface PrincipalCompany {
+  readonly name: string;
+  readonly taxNumber: string;
+  readonly invoicePrefix: string;
+  readonly zip: string;
+  readonly city: string;
+  readonly address: string;
+  readonly postalAddress?: PrincipalAddress | undefined;
+  readonly bankName?: string | undefined;
+  readonly bankAccount?: string | undefined;
+  readonly email: string;
+  readonly replyToEmail?: string | undefined;
+  readonly cashAccountingFrom?: DateInput | undefined;
+  readonly cashAccountingTo?: DateInput | undefined;
+  readonly kataFrom?: DateInput | undefined;
+  readonly kataTo?: DateInput | undefined;
+}
+interface DelegateUser {
+  readonly email: string;
+  readonly password: string;
+  readonly firstName: string;
+  readonly lastName?: string | undefined;
+}
+interface ConnectPrincipalInput {
+  readonly principal: PrincipalCompany;
+  readonly user: DelegateUser;
+}
+type ConnectPrincipalStatus = "account-created" | "owner-invite-resent" | "join-request-resent" | "join-request-sent" | "unknown";
+interface ConnectPrincipalResponse {
+  readonly status: ConnectPrincipalStatus;
+  readonly message: string;
+}
+interface ConnectPrincipalResult extends ConnectPrincipalResponse {
+  readonly taxNumber: string;
+  readonly invoicePrefix: string;
+  readonly userEmail: string;
+}
+interface ConnectPrincipalOptions extends SzamlazzOptions, RequestOptions {
+  readonly verifyTaxNumber?: boolean | undefined;
+}
+export declare function normalizeDelegateTaxNumber(value: string): string;
+export declare function assertDelegatePrefix(value: string, label?: string): string;
+export declare function buildConnectPrincipalXml(credentials: readonly XmlNode[], input: ConnectPrincipalInput): string;
+export declare function connectPrincipalStatus(message: string): ConnectPrincipalStatus;
+export declare function parseConnectPrincipalResponse(response: AgentResponse): ConnectPrincipalResponse;
+export declare function connectPrincipalWith(ctx: AgentContext, input: ConnectPrincipalInput, options?: RequestOptions & {
+  readonly verifyTaxNumber?: boolean | undefined;
+}): Promise<ConnectPrincipalResult>;
+export declare function connectPrincipal(input: ConnectPrincipalInput, options?: ConnectPrincipalOptions): Promise<ConnectPrincipalResult>;
+//#endregion
+//#region src/delegation/pool.d.ts
+export declare const DEFAULT_POOL_SIZE = 100;
+interface DelegateCredentials {
+  readonly username: string;
+  readonly password: string;
+  readonly invoicePrefix: string;
+  readonly receiptPrefix?: string | undefined;
+  readonly defaults?: KasszaDefaults | undefined;
+}
+interface DelegateKasszaOptions extends Omit<KasszaOptions, "agentKey" | "username" | "password" | "defaults">, DelegateCredentials {}
+type DelegateResolver = (principalId: string) => DelegateCredentials | undefined | Promise<DelegateCredentials | undefined>;
+interface KasszaPoolOptions extends Omit<KasszaOptions, "agentKey" | "username" | "password" | "defaults"> {
+  readonly resolve: DelegateResolver;
+  readonly maxClients?: number | undefined;
+}
+interface KasszaPool {
+  get(principalId: string): Promise<Kassza>;
+  forget(principalId: string): void;
+  clear(): void;
+  readonly size: number;
+}
+export declare function createDelegateKassza(options: DelegateKasszaOptions): Kassza;
+export declare function createKasszaPool(options: KasszaPoolOptions): KasszaPool;
+//#endregion
+//#region src/delegation/probe.d.ts
+type DelegationState = "active" | "awaiting-approval" | "awaiting-owner-registration" | "multi-account-user";
+interface DelegationProbeResult {
+  readonly state: DelegationState;
+  readonly message: string;
+  readonly error?: SzamlazzError | undefined;
+}
+interface ProbeDelegationOptions extends SzamlazzOptions, RequestOptions {}
+export declare const DELEGATION_PROBE_INVOICE_NUMBER = "KASSZA-DELEGATION-PROBE-0";
+export declare function probeDelegation(options: ProbeDelegationOptions): Promise<DelegationProbeResult>;
+//#endregion
+export { type ConnectPrincipalInput, type ConnectPrincipalOptions, type ConnectPrincipalResponse, type ConnectPrincipalResult, type ConnectPrincipalStatus, type DelegateCredentials, type DelegateKasszaOptions, type DelegateResolver, type DelegateUser, type DelegationProbeResult, type DelegationState, type KasszaPool, type KasszaPoolOptions, type PrincipalAddress, type PrincipalCompany, type ProbeDelegationOptions, suggestedPrefix };