kassza 0.13.0 → 0.14.0

package/dist/journal/index.js

@@ -0,0 +1,445 @@
+import { r as SzamlazzError } from "../errors-DtN4g5Z9.js";
+import { n as isUncertainOutcome } from "../once-CqqZxsXG.js";
+import { i as toBudapestTimestamp, n as toAgentDate, t as addBudapestDays } from "../dates-CXyj7Azy.js";
+//#region src/journal/dates.ts
+const MAX_JOURNAL_RANGE_DAYS = 366;
+const DAY_IN_MS = 864e5;
+function invalid(message) {
+	return new SzamlazzError(message, { category: "validation" });
+}
+function parseDay(value, field) {
+	try {
+		return toAgentDate(value);
+	} catch {
+		throw invalid(`A napló ${field} dátuma YYYY-MM-DD formájú legyen, kapott: ${value}`);
+	}
+}
+function dayNumber(day) {
+	return Date.parse(`${day}T00:00:00Z`) / DAY_IN_MS;
+}
+function normalizeRange(range) {
+	const from = parseDay(range.from, "from");
+	const to = parseDay(range.to, "to");
+	const span = dayNumber(to) - dayNumber(from) + 1;
+	if (span < 1) throw invalid(`A napló időszakának kezdete (${from}) később van, mint a vége (${to}).`);
+	if (span > 366) throw invalid(`A napló egyszerre legfeljebb 366 napot kérdez le, kapott: ${span} nap.`);
+	return {
+		from,
+		to
+	};
+}
+function daysOf(range) {
+	const { from, to } = normalizeRange(range);
+	const days = [];
+	const last = dayNumber(to);
+	for (let day = dayNumber(from); day <= last; day++) days.push((/* @__PURE__ */ new Date(day * DAY_IN_MS)).toISOString().slice(0, 10));
+	return days;
+}
+function inRange(day, range) {
+	return day >= range.from && day <= range.to;
+}
+function recentRange(now, days) {
+	return {
+		from: addBudapestDays(now, -(days - 1)),
+		to: toAgentDate(now)
+	};
+}
+//#endregion
+//#region src/journal/entries.ts
+function withoutPdf(receipt) {
+	if (receipt.pdf === void 0) return receipt;
+	const { pdf: _pdf, ...rest } = receipt;
+	return rest;
+}
+function compact(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0));
+}
+function inputDate(value, fallback) {
+	if (value instanceof Date || typeof value === "string") try {
+		return toAgentDate(value);
+	} catch {
+		return fallback;
+	}
+	return fallback;
+}
+function receiptEntry(receipt, source, now) {
+	const reversal = receipt.type === "reversal";
+	return compact({
+		kind: "receipt",
+		type: reversal ? "reversal" : "document",
+		number: receipt.number,
+		date: inputDate(receipt.issueDate, toAgentDate(now)),
+		recordedAt: toBudapestTimestamp(now),
+		source,
+		orderNumber: receipt.orderNumber,
+		reversedNumber: reversal ? receipt.reversedReceiptNumber : void 0,
+		netTotal: receipt.totals.netAmount,
+		grossTotal: receipt.totals.grossAmount,
+		currency: receipt.currency,
+		isTest: receipt.isTest,
+		receipt: withoutPdf(receipt)
+	});
+}
+function invoiceDetailsEntry(details, source, now) {
+	const reversal = details.header.type === "reversal";
+	return compact({
+		kind: "invoice",
+		type: reversal ? "reversal" : "document",
+		number: details.header.number,
+		date: inputDate(details.header.issueDate, toAgentDate(now)),
+		recordedAt: toBudapestTimestamp(now),
+		source,
+		orderNumber: details.header.orderNumber,
+		reversedNumber: reversal ? details.header.referencedInvoiceNumber : void 0,
+		netTotal: details.totals.netAmount,
+		grossTotal: details.totals.grossAmount,
+		currency: details.header.currency,
+		isTest: details.header.test
+	});
+}
+function invoiceResultEntry(result, orderNumber, source, now) {
+	if (result.details) return invoiceDetailsEntry(result.details, source, now);
+	return compact({
+		kind: "invoice",
+		type: "document",
+		number: result.number,
+		date: toAgentDate(now),
+		recordedAt: toBudapestTimestamp(now),
+		source,
+		orderNumber,
+		netTotal: result.invoice?.netTotal,
+		grossTotal: result.invoice?.grossTotal
+	});
+}
+function eventEntry(event, now) {
+	const today = toAgentDate(now);
+	const recordedAt = toBudapestTimestamp(now);
+	if (event.kind === "receipt") return receiptEntry(event.document, "hook", now);
+	if (event.action === "payment") return void 0;
+	if (event.action === "created") return compact({
+		kind: "invoice",
+		type: "document",
+		number: event.number,
+		date: inputDate(event.input.issueDate, today),
+		recordedAt,
+		source: "hook",
+		orderNumber: event.input.orderNumber?.trim() || void 0,
+		netTotal: event.document.netTotal,
+		grossTotal: event.document.grossTotal,
+		currency: event.input.currency
+	});
+	return compact({
+		kind: "invoice",
+		type: "reversal",
+		number: event.number,
+		date: today,
+		recordedAt,
+		source: "hook",
+		reversedNumber: event.reversedNumber,
+		netTotal: event.document.netTotal,
+		grossTotal: event.document.grossTotal
+	});
+}
+//#endregion
+//#region src/journal/journal.ts
+const DEFAULT_PENDING_DAYS = 30;
+var JournalWriteError = class extends Error {
+	name = "JournalWriteError";
+	result;
+	orderNumber;
+	constructor(orderNumber, result, cause) {
+		super(`A(z) ${orderNumber} rendelés bizonylata elkészült, de a naplóba írás nem sikerült. A tétel befejezetlenként a naplóban maradt: a journal.settle() később pótolja. Ne állítsd ki újra a bizonylatot.`, { cause });
+		this.orderNumber = orderNumber;
+		this.result = result;
+	}
+};
+function requireOrderNumber(orderNumber) {
+	const trimmed = orderNumber?.trim();
+	if (!trimmed) throw new SzamlazzError("A naplóhoz add meg a rendelésszámot (orderNumber).", { category: "validation" });
+	return trimmed;
+}
+const UNSETTLED_CATEGORIES = /* @__PURE__ */ new Set(["in_progress", "store_unavailable"]);
+function isDefinitelyNotCreated(error) {
+	if (!(error instanceof SzamlazzError)) return false;
+	return !isUncertainOutcome(error) && !UNSETTLED_CATEGORIES.has(error.category) && error.details?.outcome !== "unknown";
+}
+function archivedReceipt(item) {
+	return "receipt" in item && typeof item.receipt === "object" ? item.receipt : item;
+}
+function archiveRange(receipts) {
+	const dates = receipts.map((receipt) => receipt.issueDate).filter((date) => /^\d{4}-\d{2}-\d{2}$/.test(date));
+	if (dates.length === 0) return void 0;
+	const sorted = [...dates].sort();
+	return {
+		from: sorted[0],
+		to: sorted[sorted.length - 1]
+	};
+}
+function createJournal(storage, options = {}) {
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	const put = (entry) => entry ? storage.putEntry(entry) : Promise.resolve(false);
+	async function reserve(kind, orderNumber) {
+		const current = now();
+		return storage.putReservation({
+			kind,
+			orderNumber: requireOrderNumber(orderNumber),
+			date: toAgentDate(current),
+			reservedAt: toBudapestTimestamp(current)
+		});
+	}
+	async function release(kind, orderNumber) {
+		await storage.deleteReservation(kind, requireOrderNumber(orderNumber));
+	}
+	async function track(kind, orderNumber, run, entryOf) {
+		const order = requireOrderNumber(orderNumber);
+		const ownsReservation = await reserve(kind, order);
+		let result;
+		try {
+			result = await run();
+		} catch (error) {
+			if (ownsReservation && isDefinitelyNotCreated(error)) await storage.deleteReservation(kind, order);
+			throw error;
+		}
+		try {
+			await storage.putEntry(entryOf(result));
+			await storage.deleteReservation(kind, order);
+		} catch (error) {
+			throw new JournalWriteError(order, result, error);
+		}
+		return result;
+	}
+	async function settleOne(api, reservation) {
+		if (reservation.kind === "receipt") {
+			if (!api.receipts) throw new TypeError("A nyugták rendezéséhez add meg a receipts API-t.");
+			const receipt = await api.receipts.find({
+				orderNumber: reservation.orderNumber,
+				downloadPdf: false
+			});
+			if (!receipt) return "notFound";
+			await storage.putEntry(receiptEntry(receipt, "settle", now()));
+			return "recorded";
+		}
+		if (!api.invoices) throw new TypeError("A számlák rendezéséhez add meg az invoices API-t.");
+		const details = await api.invoices.find({ orderNumber: reservation.orderNumber });
+		if (!details) return "notFound";
+		await storage.putEntry(invoiceDetailsEntry(details, "settle", now()));
+		return "recorded";
+	}
+	const journal = {
+		storage,
+		async record(event) {
+			await put(eventEntry(event, now()));
+		},
+		recordReceipt: (receipt) => storage.putEntry(receiptEntry(receipt, "manual", now())),
+		recordInvoice: (details) => storage.putEntry(invoiceDetailsEntry(details, "manual", now())),
+		reserve,
+		release,
+		trackReceipt: (orderNumber, run) => track("receipt", orderNumber, run, (result) => receiptEntry("receipt" in result ? result.receipt : result, "track", now())),
+		trackInvoice: (orderNumber, run) => track("invoice", orderNumber, run, (result) => invoiceResultEntry(result, requireOrderNumber(orderNumber), "track", now())),
+		async entries(query) {
+			return (await storage.listEntries(normalizeRange(query))).filter((entry) => query.kind === void 0 || entry.kind === query.kind).sort((a, b) => a.date.localeCompare(b.date) || a.number.localeCompare(b.number, "hu"));
+		},
+		async receipts(query) {
+			return (await journal.entries({
+				...query,
+				kind: "receipt"
+			})).map((entry) => entry.receipt).filter((receipt) => receipt !== void 0).filter((receipt) => query.includeTest === true || !receipt.isTest);
+		},
+		async pending(range) {
+			return storage.listReservations(range ?? recentRange(now(), 30));
+		},
+		async settle(api, settleOptions = {}) {
+			const reservations = await journal.pending(settleOptions.range);
+			const recorded = [];
+			const notFound = [];
+			const failed = [];
+			for (const reservation of reservations) try {
+				const outcome = await settleOne(api, reservation);
+				if (outcome === "recorded" || settleOptions.releaseNotFound === true) await storage.deleteReservation(reservation.kind, reservation.orderNumber);
+				if (outcome === "recorded") recorded.push(reservation);
+				else notFound.push(reservation);
+			} catch (error) {
+				failed.push({
+					reservation,
+					error
+				});
+			}
+			return {
+				recorded,
+				notFound,
+				failed
+			};
+		},
+		async reconcile(archive, reconcileOptions = {}) {
+			const receipts = archive.map(archivedReceipt);
+			const derived = archiveRange(receipts);
+			const range = reconcileOptions.from !== void 0 || reconcileOptions.to !== void 0 ? normalizeRange({
+				from: reconcileOptions.from ?? derived?.from ?? reconcileOptions.to ?? "",
+				to: reconcileOptions.to ?? derived?.to ?? reconcileOptions.from ?? ""
+			}) : derived;
+			const journaled = range ? await journal.entries({
+				...range,
+				kind: "receipt"
+			}) : [];
+			const known = new Set(journaled.map((entry) => entry.number));
+			const archived = /* @__PURE__ */ new Set();
+			const added = [];
+			for (const receipt of receipts) {
+				if (archived.has(receipt.number)) continue;
+				archived.add(receipt.number);
+				if (range && !inRange(receipt.issueDate, range)) continue;
+				if (known.has(receipt.number)) continue;
+				if (reconcileOptions.dryRun !== true) await storage.putEntry(receiptEntry(receipt, "reconcile", now()));
+				added.push(receipt.number);
+			}
+			const missingFromArchive = journaled.map((entry) => entry.number).filter((number) => !archived.has(number));
+			return {
+				range,
+				added,
+				missingFromArchive,
+				matched: journaled.length - missingFromArchive.length
+			};
+		}
+	};
+	return journal;
+}
+//#endregion
+//#region src/journal/storage.ts
+const JOURNAL_KEY_PREFIX = "szamlazz:journal:";
+const DEFAULT_JOURNAL_RETENTION_DAYS = 400;
+const DEFAULT_RESERVATION_TTL_DAYS = 30;
+const DAY_IN_SECONDS = 86400;
+const READ_BATCH = 50;
+function configurationError(message) {
+	return new SzamlazzError(message, { category: "configuration" });
+}
+function positiveDays(value, fallback, field) {
+	if (value === void 0) return fallback;
+	if (!Number.isFinite(value) || value < 1) throw configurationError(`A(z) ${field} legalább 1 nap legyen, kapott: ${String(value)}`);
+	return Math.ceil(value);
+}
+function parseJson(value, guard) {
+	if (typeof value !== "string" || value === "") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		return guard(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function isEntry(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const entry = value;
+	return (entry.kind === "invoice" || entry.kind === "receipt") && typeof entry.number === "string" && typeof entry.date === "string";
+}
+function isReservation(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const reservation = value;
+	return (reservation.kind === "invoice" || reservation.kind === "receipt") && typeof reservation.orderNumber === "string" && typeof reservation.date === "string";
+}
+function slotTarget(value) {
+	if (typeof value !== "string") return void 0;
+	const separator = value.indexOf(":");
+	if (separator <= 0) return void 0;
+	const kind = value.slice(0, separator);
+	if (kind !== "invoice" && kind !== "receipt") return void 0;
+	return [kind, value.slice(separator + 1)];
+}
+async function inBatches(items, run) {
+	const results = [];
+	for (let index = 0; index < items.length; index += READ_BATCH) results.push(...await Promise.all(items.slice(index, index + READ_BATCH).map(run)));
+	return results;
+}
+function kvJournal(store, options = {}) {
+	const increment = store.increment?.bind(store);
+	if (!increment) throw configurationError("A naplóhoz olyan tároló kell, amely atomikusan tud számlálót növelni (increment), különben párhuzamos írásnál bejegyzés veszhet el. Használd a kassza/stores Redis, Upstash vagy Durable Object tárolóját. A Cloudflare KV erre nem alkalmas.");
+	const prefix = options.prefix ?? "szamlazz:journal:";
+	const retention = positiveDays(options.retentionDays, 400, "retentionDays") * DAY_IN_SECONDS;
+	const reservationTtl = positiveDays(options.reservationTtlDays, 30, "reservationTtlDays") * DAY_IN_SECONDS;
+	const entryKey = (kind, number) => `${prefix}entry:${kind}:${number}`;
+	const reservationKey = (kind, orderNumber) => `${prefix}reservation:${kind}:${orderNumber}`;
+	async function appendToDay(index, day, target, ttl) {
+		const slot = await increment?.(`${prefix}${index}:${day}:count`, ttl);
+		await store.set(`${prefix}${index}:${day}:${slot}`, target, ttl);
+	}
+	async function slotsOf(index, range) {
+		const targets = [];
+		for (const day of daysOf(range)) {
+			const count = Number.parseInt(await store.get(`${prefix}${index}:${day}:count`) ?? "0", 10);
+			if (!Number.isInteger(count) || count < 1) continue;
+			const slots = Array.from({ length: count }, (_, slot) => `${prefix}${index}:${day}:${slot + 1}`);
+			for (const value of await inBatches(slots, async (key) => store.get(key))) if (typeof value === "string") targets.push(value);
+		}
+		return [...new Set(targets)];
+	}
+	return {
+		async getEntry(kind, number) {
+			return parseJson(await store.get(entryKey(kind, number)), isEntry);
+		},
+		async putEntry(entry) {
+			const key = entryKey(entry.kind, entry.number);
+			const existing = await store.get(key);
+			if (existing !== void 0 && existing !== null) return false;
+			await appendToDay("day", entry.date, `${entry.kind}:${entry.number}`, retention);
+			const value = JSON.stringify(entry);
+			if (store.setIfAbsent) return store.setIfAbsent(key, value, retention);
+			await store.set(key, value, retention);
+			return true;
+		},
+		async listEntries(range) {
+			const normalized = normalizeRange(range);
+			return (await inBatches((await slotsOf("day", normalized)).map(slotTarget).filter((t) => t !== void 0), async ([kind, number]) => parseJson(await store.get(entryKey(kind, number)), isEntry))).filter((entry) => entry !== void 0 && inRange(entry.date, normalized));
+		},
+		async putReservation(reservation) {
+			const key = reservationKey(reservation.kind, reservation.orderNumber);
+			const value = JSON.stringify(reservation);
+			await appendToDay("rday", reservation.date, `${reservation.kind}:${reservation.orderNumber}`, reservationTtl);
+			if (store.setIfAbsent) return store.setIfAbsent(key, value, reservationTtl);
+			const existing = await store.get(key);
+			if (existing !== void 0 && existing !== null) return false;
+			await store.set(key, value, reservationTtl);
+			return true;
+		},
+		async deleteReservation(kind, orderNumber) {
+			await store.delete(reservationKey(kind, orderNumber));
+		},
+		async listReservations(range) {
+			return (await inBatches((await slotsOf("rday", normalizeRange(range))).map(slotTarget).filter((t) => t !== void 0), async ([kind, orderNumber]) => parseJson(await store.get(reservationKey(kind, orderNumber)), isReservation))).filter((reservation) => reservation !== void 0);
+		}
+	};
+}
+function memoryJournal() {
+	const entries = /* @__PURE__ */ new Map();
+	const reservations = /* @__PURE__ */ new Map();
+	const key = (kind, id) => `${kind}:${id}`;
+	return {
+		async getEntry(kind, number) {
+			return entries.get(key(kind, number));
+		},
+		async putEntry(entry) {
+			const id = key(entry.kind, entry.number);
+			if (entries.has(id)) return false;
+			entries.set(id, entry);
+			return true;
+		},
+		async listEntries(range) {
+			const normalized = normalizeRange(range);
+			return [...entries.values()].filter((entry) => inRange(entry.date, normalized));
+		},
+		async putReservation(reservation) {
+			const id = key(reservation.kind, reservation.orderNumber);
+			if (reservations.has(id)) return false;
+			reservations.set(id, reservation);
+			return true;
+		},
+		async deleteReservation(kind, orderNumber) {
+			reservations.delete(key(kind, orderNumber));
+		},
+		async listReservations(range) {
+			const normalized = normalizeRange(range);
+			return [...reservations.values()].filter((reservation) => inRange(reservation.date, normalized));
+		}
+	};
+}
+//#endregion
+export { DEFAULT_JOURNAL_RETENTION_DAYS, DEFAULT_PENDING_DAYS, DEFAULT_RESERVATION_TTL_DAYS, JOURNAL_KEY_PREFIX, JournalWriteError, MAX_JOURNAL_RANGE_DAYS, createJournal, kvJournal, memoryJournal };

package/dist/journal-DvI81Kt7.d.cts

@@ -0,0 +1,114 @@
+import { f as DocumentEvent } from "./context-CFNKzStE.cjs";
+import { r as Receipt } from "./types-lnKkQdot.cjs";
+import { n as InvoiceDetails } from "./get-Byc9T5WO.cjs";
+import { n as InvoiceOnceResult, t as ReceiptOnceResult } from "./create-once-Bh6fOWkW.cjs";
+import { t as DataLinkArchivedReceipt } from "./push-D4nNbCNV.cjs";
+//#region src/journal/types.d.ts
+type JournalDocumentKind = "invoice" | "receipt";
+type JournalEntryType = "document" | "reversal";
+type JournalEntrySource = "hook" | "track" | "reconcile" | "settle" | "manual";
+interface JournalEntry {
+  readonly kind: JournalDocumentKind;
+  readonly type: JournalEntryType;
+  readonly number: string;
+  readonly date: string;
+  readonly recordedAt: string;
+  readonly source: JournalEntrySource;
+  readonly orderNumber?: string | undefined;
+  readonly reversedNumber?: string | undefined;
+  readonly netTotal?: number | undefined;
+  readonly grossTotal?: number | undefined;
+  readonly currency?: string | undefined;
+  readonly isTest?: boolean | undefined;
+  readonly receipt?: Receipt | undefined;
+}
+interface JournalReservation {
+  readonly kind: JournalDocumentKind;
+  readonly orderNumber: string;
+  readonly date: string;
+  readonly reservedAt: string;
+}
+interface JournalRange {
+  readonly from: string;
+  readonly to: string;
+}
+interface JournalStorage {
+  getEntry(kind: JournalDocumentKind, number: string): Promise<JournalEntry | undefined>;
+  putEntry(entry: JournalEntry): Promise<boolean>;
+  listEntries(range: JournalRange): Promise<JournalEntry[]>;
+  putReservation(reservation: JournalReservation): Promise<boolean>;
+  deleteReservation(kind: JournalDocumentKind, orderNumber: string): Promise<void>;
+  listReservations(range: JournalRange): Promise<JournalReservation[]>;
+}
+//#endregion
+//#region src/journal/journal.d.ts
+declare const DEFAULT_PENDING_DAYS = 30;
+declare class JournalWriteError extends Error {
+  override readonly name: string;
+  readonly result: unknown;
+  readonly orderNumber: string;
+  constructor(orderNumber: string, result: unknown, cause: unknown);
+}
+interface JournalOptions {
+  readonly now?: (() => Date) | undefined;
+}
+interface JournalEntryQuery extends JournalRange {
+  readonly kind?: JournalDocumentKind | undefined;
+}
+interface JournalReceiptQuery extends JournalRange {
+  readonly includeTest?: boolean | undefined;
+}
+interface JournalReconcileOptions {
+  readonly from?: string | undefined;
+  readonly to?: string | undefined;
+  readonly dryRun?: boolean | undefined;
+}
+interface JournalReconciliation {
+  readonly range: JournalRange | undefined;
+  readonly added: readonly string[];
+  readonly missingFromArchive: readonly string[];
+  readonly matched: number;
+}
+interface JournalSettleApi {
+  readonly invoices?: {
+    find(reference: {
+      readonly orderNumber: string;
+    }): Promise<InvoiceDetails | null>;
+  };
+  readonly receipts?: {
+    find(input: {
+      readonly orderNumber: string;
+      readonly downloadPdf?: boolean;
+    }): Promise<Receipt | null>;
+  };
+}
+interface JournalSettleOptions {
+  readonly range?: JournalRange | undefined;
+  readonly releaseNotFound?: boolean | undefined;
+}
+interface JournalSettlement {
+  readonly recorded: readonly JournalReservation[];
+  readonly notFound: readonly JournalReservation[];
+  readonly failed: readonly {
+    readonly reservation: JournalReservation;
+    readonly error: unknown;
+  }[];
+}
+interface Journal {
+  readonly storage: JournalStorage;
+  record(event: DocumentEvent): Promise<void>;
+  recordReceipt(receipt: Receipt): Promise<boolean>;
+  recordInvoice(details: InvoiceDetails): Promise<boolean>;
+  reserve(kind: JournalDocumentKind, orderNumber: string): Promise<boolean>;
+  release(kind: JournalDocumentKind, orderNumber: string): Promise<void>;
+  trackReceipt(orderNumber: string, run: () => Promise<ReceiptOnceResult | Receipt>): Promise<ReceiptOnceResult | Receipt>;
+  trackInvoice(orderNumber: string, run: () => Promise<InvoiceOnceResult>): Promise<InvoiceOnceResult>;
+  entries(query: JournalEntryQuery): Promise<JournalEntry[]>;
+  receipts(query: JournalReceiptQuery): Promise<Receipt[]>;
+  pending(range?: JournalRange): Promise<JournalReservation[]>;
+  settle(api: JournalSettleApi, options?: JournalSettleOptions): Promise<JournalSettlement>;
+  reconcile(archive: readonly (Receipt | DataLinkArchivedReceipt)[], options?: JournalReconcileOptions): Promise<JournalReconciliation>;
+}
+declare function createJournal(storage: JournalStorage, options?: JournalOptions): Journal;
+//#endregion
+export { JournalRange as _, JournalReceiptQuery as a, JournalSettleApi as c, JournalWriteError as d, createJournal as f, JournalEntryType as g, JournalEntrySource as h, JournalOptions as i, JournalSettleOptions as l, JournalEntry as m, Journal as n, JournalReconcileOptions as o, JournalDocumentKind as p, JournalEntryQuery as r, JournalReconciliation as s, DEFAULT_PENDING_DAYS as t, JournalSettlement as u, JournalReservation as v, JournalStorage as y };

package/dist/journal-Y9qrIB8G.d.ts

@@ -0,0 +1,114 @@
+import { f as DocumentEvent } from "./context-kb33TgzE.js";
+import { r as Receipt } from "./types-D1zDOH_F.js";
+import { n as InvoiceDetails } from "./get-Byc9T5WO.js";
+import { n as InvoiceOnceResult, t as ReceiptOnceResult } from "./create-once-VKp0tVow.js";
+import { t as DataLinkArchivedReceipt } from "./push-BXj0Sf0Z.js";
+//#region src/journal/types.d.ts
+type JournalDocumentKind = "invoice" | "receipt";
+type JournalEntryType = "document" | "reversal";
+type JournalEntrySource = "hook" | "track" | "reconcile" | "settle" | "manual";
+interface JournalEntry {
+  readonly kind: JournalDocumentKind;
+  readonly type: JournalEntryType;
+  readonly number: string;
+  readonly date: string;
+  readonly recordedAt: string;
+  readonly source: JournalEntrySource;
+  readonly orderNumber?: string | undefined;
+  readonly reversedNumber?: string | undefined;
+  readonly netTotal?: number | undefined;
+  readonly grossTotal?: number | undefined;
+  readonly currency?: string | undefined;
+  readonly isTest?: boolean | undefined;
+  readonly receipt?: Receipt | undefined;
+}
+interface JournalReservation {
+  readonly kind: JournalDocumentKind;
+  readonly orderNumber: string;
+  readonly date: string;
+  readonly reservedAt: string;
+}
+interface JournalRange {
+  readonly from: string;
+  readonly to: string;
+}
+interface JournalStorage {
+  getEntry(kind: JournalDocumentKind, number: string): Promise<JournalEntry | undefined>;
+  putEntry(entry: JournalEntry): Promise<boolean>;
+  listEntries(range: JournalRange): Promise<JournalEntry[]>;
+  putReservation(reservation: JournalReservation): Promise<boolean>;
+  deleteReservation(kind: JournalDocumentKind, orderNumber: string): Promise<void>;
+  listReservations(range: JournalRange): Promise<JournalReservation[]>;
+}
+//#endregion
+//#region src/journal/journal.d.ts
+declare const DEFAULT_PENDING_DAYS = 30;
+declare class JournalWriteError extends Error {
+  override readonly name: string;
+  readonly result: unknown;
+  readonly orderNumber: string;
+  constructor(orderNumber: string, result: unknown, cause: unknown);
+}
+interface JournalOptions {
+  readonly now?: (() => Date) | undefined;
+}
+interface JournalEntryQuery extends JournalRange {
+  readonly kind?: JournalDocumentKind | undefined;
+}
+interface JournalReceiptQuery extends JournalRange {
+  readonly includeTest?: boolean | undefined;
+}
+interface JournalReconcileOptions {
+  readonly from?: string | undefined;
+  readonly to?: string | undefined;
+  readonly dryRun?: boolean | undefined;
+}
+interface JournalReconciliation {
+  readonly range: JournalRange | undefined;
+  readonly added: readonly string[];
+  readonly missingFromArchive: readonly string[];
+  readonly matched: number;
+}
+interface JournalSettleApi {
+  readonly invoices?: {
+    find(reference: {
+      readonly orderNumber: string;
+    }): Promise<InvoiceDetails | null>;
+  };
+  readonly receipts?: {
+    find(input: {
+      readonly orderNumber: string;
+      readonly downloadPdf?: boolean;
+    }): Promise<Receipt | null>;
+  };
+}
+interface JournalSettleOptions {
+  readonly range?: JournalRange | undefined;
+  readonly releaseNotFound?: boolean | undefined;
+}
+interface JournalSettlement {
+  readonly recorded: readonly JournalReservation[];
+  readonly notFound: readonly JournalReservation[];
+  readonly failed: readonly {
+    readonly reservation: JournalReservation;
+    readonly error: unknown;
+  }[];
+}
+interface Journal {
+  readonly storage: JournalStorage;
+  record(event: DocumentEvent): Promise<void>;
+  recordReceipt(receipt: Receipt): Promise<boolean>;
+  recordInvoice(details: InvoiceDetails): Promise<boolean>;
+  reserve(kind: JournalDocumentKind, orderNumber: string): Promise<boolean>;
+  release(kind: JournalDocumentKind, orderNumber: string): Promise<void>;
+  trackReceipt(orderNumber: string, run: () => Promise<ReceiptOnceResult | Receipt>): Promise<ReceiptOnceResult | Receipt>;
+  trackInvoice(orderNumber: string, run: () => Promise<InvoiceOnceResult>): Promise<InvoiceOnceResult>;
+  entries(query: JournalEntryQuery): Promise<JournalEntry[]>;
+  receipts(query: JournalReceiptQuery): Promise<Receipt[]>;
+  pending(range?: JournalRange): Promise<JournalReservation[]>;
+  settle(api: JournalSettleApi, options?: JournalSettleOptions): Promise<JournalSettlement>;
+  reconcile(archive: readonly (Receipt | DataLinkArchivedReceipt)[], options?: JournalReconcileOptions): Promise<JournalReconciliation>;
+}
+declare function createJournal(storage: JournalStorage, options?: JournalOptions): Journal;
+//#endregion
+export { JournalRange as _, JournalReceiptQuery as a, JournalSettleApi as c, JournalWriteError as d, createJournal as f, JournalEntryType as g, JournalEntrySource as h, JournalOptions as i, JournalSettleOptions as l, JournalEntry as m, Journal as n, JournalReconcileOptions as o, JournalDocumentKind as p, JournalEntryQuery as r, JournalReconciliation as s, DEFAULT_PENDING_DAYS as t, JournalSettlement as u, JournalReservation as v, JournalStorage as y };

package/dist/mcp/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_server = require("../server-C6PoNkdD.cjs");
+const require_server = require("../server-Dw9j8Mnd.cjs");
 exports.DEFAULT_CONFIRMATION_TTL_MS = require_server.DEFAULT_CONFIRMATION_TTL_MS;
 exports.MCP_LEGACY_VERSIONS = require_server.MCP_LEGACY_VERSIONS;
 exports.MCP_MODERN_VERSIONS = require_server.MCP_MODERN_VERSIONS;

package/dist/mcp/index.d.cts

@@ -1,4 +1,4 @@
-import { i as KasszaOptions } from "../client-B5FryKxJ.cjs";
+import { i as KasszaOptions } from "../client-SVZu25MB.cjs";
 //#region src/mcp/protocol.d.ts
 export declare const MCP_MODERN_VERSIONS: readonly string[];
 export declare const MCP_LEGACY_VERSIONS: readonly string[];