@opencxh/domain 1.287.0 → 1.290.0

package/dist/entities/agreement/index.d.ts

@@ -0,0 +1,3 @@
+export * from './period';
+export * from './schedule';
+export * from './types';

package/dist/entities/agreement/period.d.ts

@@ -0,0 +1,37 @@
+import { Agreement, AgreementInterval, AgreementLine } from './types';
+/** `a` bills more often than `b`: a monthly line in a yearly agreement would bill 12 at once. */
+export declare function isShorter(a: AgreementInterval, b: AgreementInterval): boolean;
+export interface Period {
+    from: number;
+    /** Exclusive. */
+    to: number;
+}
+/**
+ * The period of `interval` that contains `at`, on calendar boundaries.
+ *
+ * ponytail: UTC boundaries — a call at 00:30 Amsterdam time on the 1st lands in the previous
+ * month. Pass the organisation's zone offset here when that difference starts to matter.
+ */
+export declare function periodAt(at: number, interval: AgreementInterval): Period;
+/** When a line runs: its own dates inside the agreement's term. `to` absent = open-ended. */
+export declare function lineTerm(agreement: Pick<Agreement, "startsAt" | "endsAt">, line: Pick<AgreementLine, "startsAt" | "endsAt">): {
+    from: number;
+    to?: number;
+};
+/** The part of `period` a term covers, or `null` when they do not meet. */
+export declare function overlap(term: {
+    from: number;
+    to?: number;
+}, period: Period): Period | null;
+/**
+ * How much of a period a fixed line bills: 1 for a whole period, 0 when it ran only part of it
+ * and `proration` is off, the share of days when it is on (12 of 31 days = 12/31).
+ */
+export declare function periodShare(term: {
+    from: number;
+    to?: number;
+}, period: Period, proration: boolean): number;
+export type LineStatus = "planned" | "active" | "ended";
+export declare function lineStatus(agreement: Pick<Agreement, "startsAt" | "endsAt">, line: Pick<AgreementLine, "startsAt" | "endsAt">, now: number): LineStatus;
+/** Lines that run at `at` or will later — the ones whose accounts are taken. */
+export declare function currentLines<T extends Pick<AgreementLine, "startsAt" | "endsAt">>(agreement: Pick<Agreement, "startsAt" | "endsAt">, lines: readonly T[], at: number): T[];

package/dist/entities/agreement/period.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entities/agreement/schedule.d.ts

@@ -0,0 +1,80 @@
+import { Cents } from '../money/money';
+import { Period } from './period';
+import { Agreement, AgreementLine, LineBilling, LineRhythm } from './types';
+/** A fixed line keeps its own rhythm; usage follows the agreement, it is read per period. */
+export declare function rhythmOf(agreement: Pick<Agreement, "interval">, line: AgreementLine): LineRhythm;
+/** Fixed lines bill in advance unless told otherwise; usage is only known afterwards. */
+export declare function timingOf(line: AgreementLine): LineBilling;
+/** An invoice line an agreement wrote earlier, as far as scheduling cares. */
+export interface BilledLine {
+    agreementLineId: string;
+    servicePeriod: Period;
+    quantity: number;
+    unitPriceCents: Cents;
+    correction?: boolean;
+}
+/** One window of one line that is due and not yet on an invoice. */
+export interface Charge {
+    lineId: string;
+    /** The line's whole window in its rhythm: what "billed" is matched on. */
+    window: Period;
+    /** The part of it the line ran, which the invoice line says it covers. */
+    part: Period;
+    /** Fixed lines: the share of the window billed, 1 unless prorated. Usage: 1. */
+    share: number;
+    timing: LineBilling;
+}
+/** A window billed before the line's term changed, settled at the price it was billed at. */
+export interface Correction {
+    lineId: string;
+    window: Period;
+    /** The days added (positive quantity) or taken off (negative). */
+    part: Period;
+    quantity: number;
+    unitPriceCents: Cents;
+}
+/**
+ * What an agreement owes on `now`, per line: every window that is due minus the windows an
+ * invoice already covers, plus corrections for billed windows whose days changed since.
+ *
+ * Due: a window in advance on its first day, in arrears after its last, plus grace either way,
+ * so "fixed October" and "usage September" land on the same run. A window a line only partly
+ * runs, and a correction, wait for the window's end — they ride along with the next regular
+ * invoice instead of producing one of their own.
+ */
+export declare function dueCharges(agreement: Pick<Agreement, "startsAt" | "endsAt" | "interval" | "graceDays" | "proration">, lines: readonly AgreementLine[], billed: readonly BilledLine[], now: number): {
+    charges: Charge[];
+    corrections: Correction[];
+};
+export interface RunSpan {
+    timing: LineBilling;
+    from: number;
+    /** Exclusive. */
+    to: number;
+}
+/**
+ * What a run or an invoice covers, for a list: per timing the first and last service day, and how
+ * many corrections — "Vooraf okt · Achteraf sep · 1 correctie".
+ */
+export declare function runSpans(lines: readonly {
+    timing: LineBilling;
+    servicePeriod: Period;
+    correction?: boolean;
+}[]): {
+    spans: RunSpan[];
+    corrections: number;
+};
+export type DueStatus = "ready" | "needs_quantity" | "unrated" | "error";
+/** One row of "to bill": what a run on this agreement would do right now. */
+export interface DueRun {
+    agreementId: string;
+    title: string;
+    companyId: string;
+    status: DueStatus;
+    netCents: number;
+    spans: RunSpan[];
+    corrections: number;
+    needsQuantity: number;
+    unrated: number;
+    error?: string;
+}

package/dist/entities/agreement/schedule.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entities/agreement/types.d.ts

@@ -0,0 +1,167 @@
+import { PriceBand } from '../catalog/rating';
+import { Cents } from '../money/money';
+/**
+ * A standing arrangement with a customer that bills every period: number rental, licences, and
+ * the usage of an account at a source (calls on a PBX tenant).
+ *
+ * It does not hold the invoices it produced. Each invoice line it wrote carries the agreement line
+ * and the service period it covers, and those lines are the whole "what was billed" state.
+ */
+export interface Agreement {
+    id: string;
+    organizationId: string;
+    title: string;
+    companyId: string;
+    businessEntityId?: string;
+    currency: string;
+    status: AgreementStatus;
+    /** Epoch ms. The first period starts on the interval boundary at or before this. */
+    startsAt: number;
+    /** Exclusive: the first moment it no longer runs. A screen shows the day before as "last day". */
+    endsAt?: number;
+    /**
+     * A fixed line that starts or stops inside a period: `false` bills whole periods only (from the
+     * first full one, up to the last full one); `true` bills the days it ran, pro rata, and settles
+     * a window billed in advance when the line's term changes afterwards.
+     */
+    proration?: boolean;
+    interval: AgreementInterval;
+    /**
+     * Days after a window opens (in advance) or closes (in arrears) before it is due: late call
+     * records still arrive, and both land on the same run.
+     */
+    graceDays: number;
+    paymentTermKey?: string;
+    /**
+     * The account usage is read from (a PBX tenant). Usage lines without an account of their own
+     * take this one; a line may still name another, say texts from a second source.
+     */
+    sourceAccount?: UsageAccountRef;
+    lines: AgreementLine[];
+    createdBy: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export type AgreementStatus = "draft" | "active" | "ended";
+export type AgreementInterval = "month" | "quarter" | "year";
+export interface AgreementLine {
+    id: string;
+    productId: string;
+    /** Copied from the product, like a transaction line: the agreement must stay readable. */
+    name: string;
+    /**
+     * Where the quantity comes from. How it is priced is the product's business (`pricing`), and a
+     * price for this agreement is a price agreement with `contractId` = the agreement.
+     */
+    quantity: LineQuantity;
+    /** Taken off the quantity before the price: "the first 5 are included". */
+    included?: number;
+    /**
+     * When this line runs, inside the agreement's own term. Absent = with the agreement. A change
+     * "from 1 May" ends one line and starts another, so billed periods keep saying what they said.
+     */
+    startsAt?: number;
+    /** Exclusive, like `Agreement.endsAt`. */
+    endsAt?: number;
+    /** A fixed line only: usage is known after the period, so it always bills in arrears. */
+    billing?: LineBilling;
+    /** A fixed line's own rhythm; never shorter than the agreement's. Absent = the agreement's. */
+    every?: LineRhythm;
+}
+export type LineBilling = "advance" | "arrears";
+export type LineRhythm = AgreementInterval | "once";
+export type LineQuantity = {
+    from: "fixed";
+    value: number;
+}
+/** Entered per period, when billing. */
+ | {
+    from: "manual";
+}
+/** Read from a usage source. No `accountRef` = the agreement's `sourceAccount`. */
+ | {
+    from: "meter";
+    app: string;
+    meter: string;
+    accountRef?: string;
+};
+/** An account at a usage source: which app reports it, and its id there. */
+export interface UsageAccountRef {
+    app: string;
+    accountRef: string;
+}
+/** The account a meter line reads, own or inherited. `null` when neither names one. */
+export declare function usageAccountOf(agreement: Pick<Agreement, "sourceAccount">, line: AgreementLine): UsageAccountRef | null;
+/** Every account an agreement reads usage from, deduplicated. */
+export declare function usageAccountsOf(agreement: Pick<Agreement, "sourceAccount" | "lines">): UsageAccountRef[];
+export interface SaveAgreementRequest extends Partial<Omit<Agreement, "id" | "organizationId" | "createdBy" | "createdAt" | "updatedAt">> {
+    id?: string;
+}
+/** What a billing run would put on the invoice, before anything is written. */
+export interface AgreementRunPreview {
+    /** The moment it was computed for: everything due by then and not yet billed. */
+    at: number;
+    /** The earliest and latest service day on it. Absent when nothing is due. */
+    covers?: {
+        from: number;
+        to: number;
+    };
+    lines: RunLine[];
+    netCents: Cents;
+    /** Records without a rate, per dimension combination. Billing needs `skipUnrated` then. */
+    unrated: {
+        meter: string;
+        dimensions: Record<string, string>;
+        count: number;
+    }[];
+    /** Quantity keys of manual lines still waiting for a number. Billing refuses until given. */
+    needsQuantity: string[];
+    /** Records seen across all meter lines, rated or not. */
+    records: number;
+}
+export interface RunLine {
+    /** The agreement line it came from; a rated line yields one invoice line per rate. */
+    lineId: string;
+    name: string;
+    productId: string;
+    unitKey: string;
+    taxRateKey: string;
+    quantity: number;
+    unitPriceCents: Cents;
+    priceSourceKey: string;
+    /** What it covers: the part of the line's window it ran. */
+    servicePeriod: {
+        from: number;
+        to: number;
+    };
+    timing: LineBilling;
+    /** Settles a window that was billed before the line's term changed. */
+    correction?: boolean;
+    /** Manual lines: the key its entered quantity travels under — see `quantityKey`. */
+    quantityKey?: string;
+    /** A fixed line that ran part of its window: the share billed. */
+    share?: number;
+    /** Hours read from the time app: the invoice stamps them, so nothing bills them again. */
+    timeEntryIds?: string[];
+    usage?: LineUsage;
+}
+/** Manual quantities are entered per line and window: a catch-up run may ask for two months. */
+export declare function quantityKey(lineId: string, windowFrom: number): string;
+/**
+ * How a usage line was counted, kept on the invoice line. A rated group bills 1 × its total (it
+ * has no whole-cent unit price), so the real quantity and the tier bands live here.
+ */
+export interface LineUsage {
+    from: "manual" | "meter";
+    /** Rated lines: the rate this group is. */
+    rateId?: string;
+    records?: number;
+    /** Aggregated, before `included`. */
+    measured: number;
+    included?: number;
+    /** For display: the meter's display unit (`minute`) or the product's unit. */
+    unit: string;
+    /** Meter units per display unit (60 seconds per minute). */
+    per: number;
+    bands?: PriceBand[];
+}

package/dist/entities/bank/bank.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entities/bank/index.d.ts

@@ -0,0 +1,3 @@
+export * from './match';
+export * from './parse';
+export * from './types';

package/dist/entities/bank/match.d.ts

@@ -0,0 +1,52 @@
+import { Cents } from '../money/money';
+import { BankLine, BankRule, MatchProposal, Reconciliation } from './types';
+/**
+ * A proposal for one bank line, in the order of the datamodel (§6.1): a reference with the
+ * amount, then an IBAN with the amount, then a transfer between own accounts, then a rule.
+ * Nothing guessed: no proposal is better than a wrong one in "Klaar om te bevestigen".
+ */
+/** An open sales invoice (money in) or receipt (money out), with what is still open. */
+export interface OpenDocument {
+    kind: "sales_invoice" | "receipt";
+    id: string;
+    sourceApp?: string;
+    number?: string;
+    /** IBANs this party pays from or to (crm `Company.ibans`, or the receipt's). */
+    ibans: string[];
+    /** Positive: what is still to receive (an invoice) or to pay (a receipt). */
+    openCents: Cents;
+    label: string;
+}
+export interface MatchContext {
+    documents: readonly OpenDocument[];
+    rules: readonly BankRule[];
+    /** Our own accounts, to recognise a transfer. */
+    ownIbans: readonly {
+        iban: string;
+        bankAccountId: string;
+    }[];
+    /** Instalments waiting for their bank line: the amount to expect, when, and the party's IBANs. */
+    scheduled?: readonly {
+        id: string;
+        expectedBankCents: Cents;
+        dueOn: string;
+        ibans: string[];
+        label: string;
+    }[];
+    /** Unbooked lines on other own accounts, for the other side of a transfer. */
+    otherLines: readonly Pick<BankLine, "id" | "bankAccountId" | "date" | "amountCents" | "state">[];
+}
+export declare function proposeMatch(line: Pick<BankLine, "bankAccountId" | "date" | "amountCents" | "counterpartyIban" | "description" | "endToEndId">, context: MatchContext): MatchProposal | undefined;
+/** What is left of an item: its amount minus every active allocation on it. Computed, never stored. */
+export declare function openCentsOf(itemKey: string, amountCents: Cents, reconciliations: readonly Pick<Reconciliation, "status" | "allocations">[]): Cents;
+/** The invariant of a reconciliation: its allocations cancel out (a difference is in the entry). */
+export declare function reconciliationBalances(rec: Pick<Reconciliation, "allocations">): boolean;
+/**
+ * The whole payment state of an item from its amount and what is still open, both signed like
+ * the item (an invoice +, a receipt −). What sales hears, and what the books show.
+ */
+export declare function paymentOfItem(grossCents: Cents, openCents: Cents): {
+    state: "paid" | "overpaid" | "unpaid" | "partially_paid";
+    paidCents: number;
+    openCents: number;
+};

package/dist/entities/bank/parse.d.ts

@@ -0,0 +1,13 @@
+import { ParsedStatement } from './types';
+/** Every `<tag>…</tag>` body at any depth, in order. Tags are matched by local name. */
+declare function blocks(xml: string, tag: string): string[];
+/** The text at a path of tags: `first(x, "BookgDt", "Dt")`. */
+declare function first(xml: string, ...path: string[]): string | undefined;
+/** ISO 20022 camt.053: one statement per file is the common case; every `Stmt` is read. */
+export declare function parseCamt053(input: string): ParsedStatement;
+/** SWIFT MT940, as Dutch banks export it. Several statements in one file are read in order. */
+export declare function parseMt940(input: string): ParsedStatement;
+/** Which format a file is in, by its content, not its name. */
+export declare function parseStatement(input: string): ParsedStatement;
+/** The same scanner for other flat XML the browser reads (the XAF import). */
+export { blocks as xmlBlocks, first as xmlText };

package/dist/entities/bank/types.d.ts

@@ -0,0 +1,197 @@
+import { Cents } from '../money/money';
+/**
+ * Bank accounts, statements and their lines, and settling one with the other (plan 039
+ * datamodel §5.1, §6.1–6.3). Only the bank kinds of `SubAccount` are built here; loans, the
+ * director's current account and participations follow in step 6b on the same row.
+ */
+export type BankSubAccountKind = "bank" | "savings" | "deposit" | "credit_card" | "psp" | "cash";
+/** A bank account (or cash, a card, a payment provider balance) under a ledger account. */
+export interface BankAccount {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    kind: BankSubAccountKind;
+    name: string;
+    /** The ledger account it sits under (`1100 Bank`), and the bank journal its lines post in. */
+    ledgerAccountId: string;
+    journalId: string;
+    iban?: string;
+    currency: string;
+    archived?: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface BankImport {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    bankAccountId: string;
+    format: "camt053" | "mt940";
+    from: string;
+    to: string;
+    /** What the statement says. A difference with our balance is a signal, never a silent fix. */
+    statementOpeningCents?: Cents;
+    statementClosingCents?: Cents;
+    lineCount: number;
+    importedBy: string;
+    createdAt?: number;
+}
+/** A line as a parser reads it from a statement, before it is stored. */
+export interface ParsedBankLine {
+    date: string;
+    valueDate?: string;
+    /** Positive = money in. */
+    amountCents: Cents;
+    currency: string;
+    counterpartyName?: string;
+    counterpartyIban?: string;
+    description: string;
+    endToEndId?: string;
+    /**
+     * Unique per account: the bank's own reference (CAMT `AcctSvcrRef`, MT940 `:61:` reference), or
+     * else statement number + line number. Never date + amount + text alone: two coffees of € 3,20
+     * on one day are two lines.
+     */
+    dedupeKey: string;
+}
+export interface ParsedStatement {
+    format: BankImport["format"];
+    iban?: string;
+    currency?: string;
+    from: string;
+    to: string;
+    openingCents?: Cents;
+    closingCents?: Cents;
+    lines: ParsedBankLine[];
+}
+/** What a bank line is paired with. The pair lives on the line only; nothing points back. */
+export type MatchTarget = {
+    kind: "sales_invoice";
+    transactionId: string;
+    sourceApp: string;
+} | {
+    kind: "receipt";
+    receiptId: string;
+}
+/** A prepared posting from a balance item's schedule: a loan instalment. */
+ | {
+    kind: "scheduled_posting";
+    scheduledPostingId: string;
+}
+/** The other side of a transfer between two own accounts. */
+ | {
+    kind: "transfer";
+    bankLineId: string;
+}
+/** Straight to an account (bank costs, a rule). */
+ | {
+    kind: "account";
+    accountId: string;
+    taxCode?: string;
+    description?: string;
+};
+export type MatchReason = "amount" | "iban" | "reference" | "invoice_number" | "date_window" | "rule" | "own_account";
+export interface MatchProposal {
+    target: MatchTarget;
+    via: "exact" | "rule" | "manual";
+    confidence: "high" | "medium" | "low";
+    ruleId?: string;
+    /** What agreed, for the explanation on screen: "same amount, same IBAN". */
+    reasons: MatchReason[];
+    /** What the target is called, so the queue need not look it up: "F2026-0190 · Studio Noord". */
+    label?: string;
+}
+export interface BankLine extends ParsedBankLine {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    bankAccountId: string;
+    importId: string;
+    /** Computed at import and after, stored so the queue loads fast. */
+    proposal?: MatchProposal;
+    /** unmatched → booked (entry and reconciliation written) · ignored. */
+    state: "unmatched" | "booked" | "ignored";
+    /** What it was booked against, and the entry that did it. */
+    pairedWith?: MatchTarget;
+    entryId?: string;
+    /**
+     * How often it was booked and undone: the entry's source key is `bank:<id>:<attempt>`, so booking
+     * again after an undo makes a new entry instead of finding the reversed one.
+     */
+    attempt?: number;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/** Made by a person, or offered after a manual pairing ("Voortaan automatisch?"). */
+export interface BankRule {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    name: string;
+    /** Every condition given must hold. */
+    when: {
+        bankAccountId?: string;
+        counterpartyIban?: string;
+        /** Case-insensitive, in memory (the store has no `$regex`). */
+        descriptionContains?: string;
+        direction?: "in" | "out";
+    };
+    action: {
+        accountId: string;
+        taxCode?: string;
+        description?: string;
+    };
+    /** High lands in "Klaar om te bevestigen", medium in "Controleren". */
+    confidence: "high" | "medium";
+    order: number;
+}
+/** An item that can be open: a posted line (debtor, creditor), or a bank line. */
+export type OpenItemRef = {
+    kind: "journal_line";
+    id: string;
+} | {
+    kind: "bank_line";
+    id: string;
+};
+/**
+ * One reconciliation: amounts that cancel out. Immutable once active; undoing sets `reversed`
+ * and deletes nothing, so the history stays (datamodel §6.3).
+ */
+export interface Reconciliation {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    /** `bank:<bankLineId>` while active; a reversed one gets `:reversed:<at>` so the line can pair again. Unique. */
+    reconKey: string;
+    kind: "payment" | "credit_offset" | "transfer" | "write_off" | "manual";
+    /**
+     * The sign follows the item: a debtor line is +, its receipt −. The allocations cancel out; a
+     * difference is booked in the payment's entry and listed below for the audit.
+     */
+    allocations: {
+        item: OpenItemRef;
+        amountCents: Cents;
+    }[];
+    differences?: {
+        amountCents: Cents;
+        reason: "payment_difference" | "bank_costs" | "fx" | "write_off";
+        accountId: string;
+        entryId: string;
+    }[];
+    /** Flat and indexed: which reconciliations touch this item is an `$in` on this field. */
+    itemKeys: string[];
+    status: "active" | "reversed";
+    origin: {
+        via: "exact" | "rule" | "manual";
+        ruleId?: string;
+        proposalReasons?: MatchReason[];
+    };
+    createdBy: string;
+    createdAt?: number;
+    reversal?: {
+        at: number;
+        by: string;
+        reason: string;
+    };
+}
+export declare const itemKeyOf: (item: OpenItemRef) => string;

package/dist/entities/bookkeeping/index.d.ts

@@ -0,0 +1,2 @@
+export * from './receipt';
+export * from './types';

package/dist/entities/bookkeeping/receipt.d.ts

@@ -0,0 +1,104 @@
+import { BookingDocument } from '../../platform/bookkeeping';
+import { Cents } from '../money/money';
+import { TaxRateKind } from '../money/tax';
+import { WorkQueueItem } from './types';
+/**
+ * A receipt or purchase invoice, as finance holds it until it is booked (plan 039 datamodel §6.4).
+ * Finance is its own `bookable-source` for these, so a receipt reaches Jortt the way an invoice
+ * does, through the same `BookingSync`.
+ */
+export interface Receipt {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    /**
+     * Where it came from, flat and unique: `mail:<activityId>:<attachmentId>` or
+     * `upload:<fileId>`. The same attachment sent to the macro twice is one receipt.
+     */
+    sourceKey: string;
+    /** The copy in storage: the books keep it seven years, a mailbox does not. */
+    file: {
+        mountId: string;
+        fileId: string;
+        filename: string;
+        mimeType: string;
+    };
+    receivedVia: "mail" | "upload";
+    receivedAt: number;
+    mail?: {
+        interactionId: string;
+        activityId: string;
+        from?: string;
+        subject?: string;
+    };
+    supplierCompanyId?: string;
+    fields: ReceiptFields;
+    lines: ReceiptLine[];
+    totals: {
+        netCents: Cents;
+        taxCents: Cents;
+        grossCents: Cents;
+    };
+    status: ReceiptStatus;
+    /** Why extraction gave nothing, when it did not: shown on the item, a person fills it in. */
+    extractError?: string;
+    /** Only the reference; the state lives on the approval request (one approval system, plan 023). */
+    approvalRequestId?: string;
+    /** When it was handed to the books: the "issue" moment the sweeper and `activeFrom` go by. */
+    bookedAt?: number;
+    postedAt?: number;
+    externalIds?: string[];
+    createdBy?: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/**
+ * extracting: the AI is reading it.
+ * to_check: something is filled in and not confirmed yet.
+ * awaiting_approval: confirmed, above the administration's threshold, waiting on a sign-off.
+ * booked: handed to the books (the `BookingSync` says whether it arrived).
+ * rejected: not a receipt, or a duplicate.
+ */
+export type ReceiptStatus = "extracting" | "to_check" | "awaiting_approval" | "booked" | "rejected";
+/** A recognised value: whether the AI proposed it, and whether a person has looked. */
+export interface Field<T> {
+    value: T;
+    ai?: boolean;
+}
+export interface ReceiptFields {
+    supplierName?: Field<string>;
+    supplierVatNumber?: Field<string>;
+    supplierIban?: Field<string>;
+    invoiceNumber?: Field<string>;
+    /** `"2026-09-24"`. */
+    issueDate?: Field<string>;
+    dueDate?: Field<string>;
+    currency?: Field<string>;
+}
+export interface ReceiptLine {
+    description?: string;
+    netCents: Cents;
+    taxCents: Cents;
+    /** `TaxCode.key`, e.g. `high`. */
+    taxRateKey: string;
+    taxPercent?: number;
+    taxKind?: TaxRateKind;
+    /** The account in the target books (`LedgerOption.key`). */
+    accountKey?: string;
+    aiSuggested?: boolean;
+}
+/** Totals from the lines: the lines are the truth, the totals follow. */
+export declare function receiptTotals(lines: readonly ReceiptLine[]): Receipt["totals"];
+export type ReceiptProblem = "no_supplier" | "no_date" | "no_lines" | "no_account";
+export declare const RECEIPT_SCOPE_KIND = "receipt";
+/** The act a sign-off on a receipt is about. */
+export declare const RECEIPT_BOOK_ACT = "book";
+/** What still stands between this receipt and the books. Empty = it can be confirmed. */
+export declare function receiptProblems(receipt: Pick<Receipt, "fields" | "lines">): ReceiptProblem[];
+/**
+ * Where it sits in "Te verwerken": ready to confirm when nothing is missing, to check when only
+ * the reading needs a look, to choose when an account is missing (no proposal to confirm).
+ */
+export declare function receiptGroupOf(receipt: Pick<Receipt, "fields" | "lines" | "status">): WorkQueueItem["group"] | null;
+/** The receipt as the books need it: a purchase, with the account per line a person chose. */
+export declare function bookingDocumentOfReceipt(receipt: Receipt, sourceApp?: string): BookingDocument;

package/dist/entities/bookkeeping/receipt.test.d.ts

@@ -0,0 +1 @@
+export {};