@opencxh/domain 1.302.0 → 1.304.0

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

@@ -1,5 +1,6 @@
 import { Cents } from '../money/money';
 import { PricePer } from '../money/period-price';
+import { LineDimensions } from '../transaction/types';
 import { MatchCandidate, MatchedVia } from './packing-slip';
 import { SupplierOffer } from './types';
 /** What an invoice line pays for: an order line, or a contract line over a period. */
@@ -41,10 +42,26 @@ export interface InvoiceCandidate extends MatchCandidate {
     discountPercent?: number;
     /** Order line: what is still to invoice. Contract line: the agreed count, `null` when counted. */
     openQty: number | null;
+    /**
+     * Goods that come to us: received minus invoiced. Absent when no receipt is expected (a service,
+     * a licence, a drop shipment): then the order is the measure, as before (Exact: 3-way match).
+     */
+    receivedOpen?: number;
     /** A contract line whose invoice decides the amount: nothing expected. */
     variable?: boolean;
     use?: "own" | "resale";
     customerCompanyId?: string;
+    /** The order's or contract's; absent = the invoice's own. */
+    currency?: string;
+    /** A contract row: the days it runs, `to` exclusive. A line is matched to the row of its period. */
+    term?: {
+        from: number;
+        to?: number;
+    };
+    /** The order line's, carried to the cost it books (plan 045 F 3b). */
+    dimensions?: LineDimensions;
+    /** The article's group in this administration: its posting rule picks the cost account. */
+    ledgerCategoryKey?: string;
 }
 export interface MatchAllocation {
     receiptLineId: string;
@@ -56,10 +73,33 @@ export interface MatchAllocation {
     expectedCents: Cents | null;
     /** More than the order line still had open, or another count than the contract's. */
     overQuantity: boolean;
+    /** More than has arrived of goods that come to us: invoiced before it was received. */
+    notReceived?: boolean;
     businessEntityId: string;
     productId?: string;
     use?: "own" | "resale";
     customerCompanyId?: string;
+    dimensions?: LineDimensions;
+    ledgerCategoryKey?: string;
+    /**
+     * The invoice in another currency than its target: one invoice unit in the target's. The
+     * amount stays as printed (it is what books); the verdict compares `amountCents × rate`.
+     */
+    rate?: number;
+}
+/** What the invoice is in, and its rate to the euro when it is not (Receipt `fxRate`). */
+export interface InvoiceMoney {
+    currency: string;
+    /** Euro per one unit of `currency`, as the receipt carries it. */
+    fxRate?: number;
+}
+export interface AllocateOptions {
+    /** The month a line without a printed period is for (the invoice's). */
+    defaultPeriod: {
+        from: number;
+        to: number;
+    };
+    invoice?: InvoiceMoney;
 }
 /**
  * Invoice lines onto order and contract lines, many to many. Each line goes to its best candidates
@@ -67,12 +107,10 @@ export interface MatchAllocation {
  * same article (10 phones over two orders of 6 and 4), the amount split by count. A contract line
  * takes the line whole, for the period printed on it or else `defaultPeriod` (the invoice's month).
  */
-export declare function allocateInvoice(lines: readonly InvoiceLine[], candidates: readonly InvoiceCandidate[], offers: readonly Pick<SupplierOffer, "id" | "productId" | "vendorSku">[], defaultPeriod: {
-    from: number;
-    to: number;
-}): {
+export declare function allocateInvoice(lines: readonly InvoiceLine[], candidates: readonly InvoiceCandidate[], offers: readonly Pick<SupplierOffer, "id" | "productId" | "vendorSku">[], { defaultPeriod, invoice }: AllocateOptions): {
     allocations: MatchAllocation[];
     unmatched: string[];
+    needsRate: string[];
 };
 export interface MatchTolerance {
     percent: number;
@@ -80,7 +118,7 @@ export interface MatchTolerance {
 }
 /** One per cent or one euro, whichever is more: a rounding difference is not work. */
 export declare const DEFAULT_TOLERANCE: MatchTolerance;
-export type MatchIssue = "price" | "quantity" | "unmatched";
+export type MatchIssue = "price" | "quantity" | "not_received" | "unmatched" | "fx_rate_required";
 export interface MatchVerdict {
     /** Everything matched, at the expected price and count: approve without a person. */
     ok: boolean;
@@ -95,4 +133,8 @@ export interface MatchVerdict {
  * Whether an invoice is what was ordered or agreed: every line matched, every count within what
  * was open, every amount within the tolerance (% and absolute). Anything else is work.
  */
-export declare function matchVerdict(allocations: readonly MatchAllocation[], unmatched: readonly string[], tolerance?: MatchTolerance): MatchVerdict;
+export declare function matchVerdict(allocations: readonly MatchAllocation[], unmatched: readonly string[], { tolerance, needsRate, }?: {
+    tolerance?: MatchTolerance;
+    /** Lines that would match in another currency: the receipt needs its rate first. */
+    needsRate?: readonly string[];
+}): MatchVerdict;

package/dist/entities/purchase/packing-slip.d.ts

@@ -72,6 +72,29 @@ export interface SlipProposal {
     })[];
     problems: SlipProblem[];
 }
+/** A packing slip as a screen reads it: an upload or a mail attachment, read by the AI. */
+export interface PackingSlipView {
+    id: string;
+    source: "upload" | "mail";
+    filename: string;
+    mimeType: string;
+    mail?: {
+        interactionId: string;
+        activityId: string;
+        attachmentId: string;
+        from?: string;
+    };
+    /** The original in the packing-slip folder. */
+    file?: {
+        mountId: string;
+        fileId: string;
+    };
+    status: "extracting" | "needs_browser" | "to_check" | "booked" | "dismissed";
+    content?: PackingSlipContent;
+    purchaseOrderId?: string;
+    extractError?: string;
+    createdAt?: number;
+}
 /**
  * A packing slip as a receipt to book: the matched lines with their counts and serials, and what a
  * person has to decide — no order, an article not on it, more than is open, serials that do not

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

@@ -1,9 +1,27 @@
-import { ProvisioningAction, ProvisioningState } from '../../platform/provisioning';
+import { ProvisioningAction, ProvisioningAnswers, ProvisioningState } from '../../platform/provisioning';
 import { LineRhythm } from '../agreement/types';
 import { Cents } from '../money/money';
 import { PricePer } from '../money/period-price';
 import { PostalAddress } from '../organization/types';
 import { Transaction, TransactionLine } from '../transaction/types';
+/** How an offer is ordered through an app, and what of that app's assortment it stands for. */
+export interface OfferProvider {
+    app: string;
+    offer: string;
+    /**
+     * The article as a filter (plan 053): fixed answers in this provider's own words
+     * (`technology: fiber`, `min_download: 1000`). They go to `prepare` with every other answer.
+     */
+    answers?: ProvisioningAnswers;
+    /**
+     * An upsell article: which of the provider's options it sells — by answer key (`evc_*` is every
+     * circuit) and option key or label (`24x7`); no `match` = every option of that answer.
+     */
+    option?: {
+        answer: string;
+        match?: string;
+    };
+}
 /**
  * What a supplier asks for a product: one row per supplier and product (and validity window).
  * The default offer is the product's cost price; the rest are the alternatives a buyer compares.
@@ -11,7 +29,7 @@ import { Transaction, TransactionLine } from '../transaction/types';
 export interface SupplierOffer {
     id: string;
     organizationId: string;
-    businessEntityId?: string;
+    businessEntityId: string;
     supplierCompanyId: string;
     productId: string;
     /** Their article number. */
@@ -39,22 +57,23 @@ export interface SupplierOffer {
     validFrom?: number;
     validTo?: number;
     minQty?: number;
+    /** Ordered in multiples of this many purchase units (Exact `PurchaseLotSize`); `minQty` is no multiple. */
+    lotSize?: number;
+    /** Ships straight to a customer: never, only, or both (Exact `DropShipment`). Absent = both. */
+    dropship?: "no" | "yes" | "optional";
+    /**
+     * `quote`: no fixed price — the provider prices each order (a connection per address, B.6b);
+     * `costCents` is then 0 and never the product's cost. Absent = `list`.
+     */
+    pricedBy?: "list" | "quote";
     leadDays?: number;
     /** Days from each term's start the supplier still takes a change (NCE: 7). */
     changeWindowDays?: number;
-    /** Ordered through an app instead of by mail (fase 9). */
-    provider?: {
-        app: string;
-        offer: string;
-    };
     /**
-     * Where it lands when that is not the supplier (fase 9b): a Telnyx number on the customer's
-     * Eylo account. The platform's own offer takes it in, after the purchase.
+     * Ordered through an app instead of by mail (fase 9). Where it lands is not the offer's to say:
+     * the provider of that platform declares what it needs (047 v2 §2.3).
      */
-    deliverTo?: {
-        app: string;
-        offer: string;
-    };
+    provider?: OfferProvider;
     /** The supplier's advised price (the Microsoft ERP price), from a feed (plan 045 G). */
     listCents?: Cents;
     /** The last known stock; only the latest, no history (plan 045 B.1). */
@@ -73,6 +92,8 @@ export interface OfferAvailability {
     at: number;
     source: "feed" | "api" | "manual";
     leadDays?: number;
+    /** Until when the choice trusts it: a feed's rhythm × 2, a hand-set stand a day. */
+    freshUntil?: number;
 }
 /** Ours to keep, or sold on to a customer — decides where the cost books (fase 6). */
 export type PurchaseUse = "own" | "resale";
@@ -83,35 +104,43 @@ export interface PurchaseLine extends TransactionLine {
     /** Matched to supplier invoices (fase 7). */
     billedQty: number;
     use: PurchaseUse;
-    dimensions?: {
-        costCenterId?: string;
-        projectId?: string;
+    /** What the supplier confirmed (Ingram `quantity_confirmed`, `quantity_back_ordered`). */
+    confirmation?: {
+        quantity: number;
+        backorder?: number;
+        promisedAt?: number;
     };
-    /** Absent = `purchase`. A change or an end points at the contract line it is about. */
-    action?: ProvisioningAction;
-    contractLine?: {
-        contractId: string;
-        lineId: string;
-    };
-    /** A change: the count it should be after. */
-    targetQuantity?: number;
-    /** When a change or end takes effect (epoch ms): the end of the term, not today. */
-    effectiveAt?: number;
-    /** Where this line came from in "Te bestellen", so it is not proposed twice. */
-    demandKey?: string;
-    /** The line of this order it waits for (the customer's account before its numbers). */
-    waitsFor?: string;
-    /** The supplier's ordering fields (a domain, a region). */
-    params?: Record<string, string>;
-    provisioning?: LineProvisioning;
-    /** The second step when the offer lands elsewhere (`deliverTo`): after a buy, before an end. */
-    delivery?: LineProvisioning;
+    /** The supplier's order for this line: one PO can become several (Ingram `order_split`). */
+    supplierRef?: string;
+    /**
+     * The fulfilment request this line pays for: fulfilment carries it out once the PO is sent. What
+     * the act is (a buy, a change, an end) is the request's; the line is what it costs.
+     */
+    fulfilmentRequestId?: string;
+    /**
+     * Server-set with the request: a change or an end on a running subscription. Absent = a buy. An
+     * act at no cost expects no invoice, so a PO of ends can be invoiced in full (review 6).
+     */
+    act?: Exclude<ProvisioningAction, "purchase">;
+    /**
+     * Goods: which of fulfilment's allocations this line buys for, in base units (047 §4). Server-
+     * set; on a draft the line's quantity is their sum, so two needs share one line only by merging.
+     */
+    allocations?: {
+        id: string;
+        quantity: number;
+    }[];
+    /**
+     * Never stored: on a read the server adds how the request this line pays for stands at
+     * fulfilment, so the order page can show it. The supplier's fields live on the request.
+     */
+    request?: LineRequest;
 }
 /**
- * A line's request at the supplier. `waiting`: its account is not there yet. `manual`: no API —
- * a person does it and fills in the result.
+ * How a line's request stands, as the order page shows it. `waiting`: not out yet (its account,
+ * its day). `manual`: no API — a person does it and fills in the result.
  */
-export interface LineProvisioning {
+export interface LineRequest {
     state: ProvisioningState | "waiting" | "manual";
     requestId: string;
     app?: string;
@@ -121,6 +150,8 @@ export interface LineProvisioning {
         key: string;
         reason: string;
     }[];
+    /** The supplier's ordering fields as the request holds them. */
+    params?: Record<string, string>;
     error?: string;
     attempts?: number;
     nextAttemptAt?: number;
@@ -134,18 +165,28 @@ export interface DeliverTo {
     /** Frozen when the order is sent: what the supplier was told, whatever crm says later. */
     address?: PostalAddress;
 }
-/** A purchase order: a `Transaction` of kind `purchase_order`; `companyId` is the supplier. */
-export interface PurchaseOrder extends Omit<Transaction, "lines"> {
-    lines: PurchaseLine[];
+/** What a purchase order goes through. Received is its own axis on the lines (`receivedQty`). */
+export type PurchaseStatus = "draft" | "sent" | "confirmed" | "received" | "cancelled" | "superseded";
+/** A purchase order: a {@link Transaction} of kind `purchase_order`; `companyId` is the supplier. */
+export interface PurchaseOrder extends Transaction<PurchaseLine, PurchaseStatus> {
     deliverTo: DeliverTo;
     /** Bought for this customer (the M365 seats for Acme). */
     customerCompanyId?: string;
+    /** `full` once every line that expects an invoice is billed: off the match and allocate scans. */
+    invoiceState?: InvoiceState;
 }
+export type InvoiceState = "open" | "full";
 export interface GoodsReceiptLine {
     poLineId: string;
     /** Purchase units; positive, the movement says the direction. */
     quantity: number;
     serials: string[];
+    /** For a batch-tracked article (046 `tracking: "batch"`): what came in per batch. */
+    batches?: {
+        code: string;
+        quantity: number;
+        expiresAt?: number;
+    }[];
     /** Still to come, as the packing slip says. */
     backorderQty?: number;
 }
@@ -153,7 +194,7 @@ export interface GoodsReceiptLine {
 export interface GoodsReceipt {
     id: string;
     organizationId: string;
-    businessEntityId?: string;
+    businessEntityId: string;
     movement: "in" | "return";
     purchaseOrderId: string;
     supplierCompanyId: string;
@@ -164,5 +205,12 @@ export interface GoodsReceipt {
     supplierRef?: string;
     status: "draft" | "booked";
     lines: GoodsReceiptLine[];
+    /** Flat and indexed: `<productId>#<serial>` of every line, for the register across orders. */
+    serialKeys?: string[];
     createdAt?: number;
 }
+/** Per administration: the storage folder packing slips are kept in. */
+export interface PurchaseSettings {
+    businessEntityId: string;
+    slipFolderId?: string;
+}

package/dist/entities/purchase/upsell.d.ts

@@ -0,0 +1,20 @@
+import { OfferProvider, SupplierOffer } from './types';
+/** One option a configuration took, as its provider named it. */
+export interface TakenOption {
+    /** The answer it comes from: `evc_2`, `sla`, `cpe`. */
+    answer: string;
+    /** The provider's own option key (`608`) and label (`24x7`). */
+    key: string;
+    label: string;
+}
+/**
+ * Whether an upsell article's rule covers an option (plan 053): the answer by name, or every
+ * numbered one with a trailing `*` (`evc_*`); then the option by key or label, or any.
+ */
+export declare function sellsOption(rule: OfferProvider["option"], option: TakenOption): boolean;
+/**
+ * The upsell article that sells this option at this provider, or none: then a colleague is told
+ * "no sales article linked" and nothing is sold without a price. The exact match wins over a
+ * catch-all (`SLA 24x7` over a rule for every SLA).
+ */
+export declare function upsellOfferFor(offers: readonly SupplierOffer[], app: string, option: TakenOption): SupplierOffer | undefined;

package/dist/entities/purchase/upsell.test.d.ts

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

package/dist/entities/reports/vat.d.ts

@@ -1,18 +1,21 @@
 import { Cents } from '../money/money';
-import { TaxCode } from '../money/tax';
+import { IcpKind, TaxCode } from '../money/tax';
 /**
  * The VAT return, computed from posted lines (plan 039 datamodel §7): every line with a VAT code
  * and a tax point in the period adds its base and VAT to the boxes of that code. Pure; the server
  * turns journal lines into `VatLine`s.
  */
 export interface VatLine {
-    /** A line on a revenue account is a sale, anything else a purchase. */
+    /** The line's `taxSide`; guessed from its account only for a line booked before that existed. */
     side: "sales" | "purchase";
     taxCode: string;
     /** Positive for a sale or a purchase, negative for its credit note. */
     baseCents: Cents;
     taxCents: Cents;
+    /** When the VAT arose: the rate is the one of this day. */
     taxPointDate: string;
+    /** The return it counts in, when that differs from the tax point's (`JournalLine.vatDate`). */
+    vatDate?: string;
     counterpartyCompanyId?: string;
     /** The journal line it came from: the drill-down from a box back to the bookings. */
     ref?: string;
@@ -31,9 +34,11 @@ export interface VatReturnFigures {
         tax?: number;
     }>>;
     /** EC sales list: per customer, the base of the reverse-charged EU sales. */
-    /** `name` and `vatNumber` are filled in from crm when the return is shown, never stored. */
+    /** `name` and `vatNumber` come from the entries' frozen party; a filed return stores them. */
+    /** Per customer and column (goods, services, triangular): the list reports them apart. */
     icp: {
         counterpartyCompanyId?: string;
+        kind: IcpKind;
         baseCents: Cents;
         name?: string;
         vatNumber?: string;
@@ -45,8 +50,9 @@ export interface VatReturnFigures {
 }
 /**
  * The boxes for one period. Reverse charge on purchase (`selfAssessed`) is owed in its own box
- * and deducted in 5b at the standard rate of its tax point; input VAT counts at the code's
- * deductible share. 5a is what is owed (1a–4b), 5b what is deducted, 5c and 5g the balance.
+ * and deducted in 5b at the standard rate of its tax point; input VAT counts as booked (its
+ * non-deductible share is already cost, `documentLinesOf`). 5a is what is owed (1a–4b), 5b what
+ * is deducted, 5c and 5g the balance.
  */
 export declare function vatReturn(input: {
     lines: readonly VatLine[];
@@ -66,3 +72,12 @@ export declare function vatPeriods(year: number, cadence?: "quarter" | "month" |
     to: string;
     dueOn: string;
 }[];
+/**
+ * The day a VAT line counts on (Exact's reporting period apart from the entry date): its tax
+ * point, or the first day after the last return filed before it was posted, when that is later.
+ * A filed return locks no period; what arrives late counts in the next one.
+ */
+export declare function vatDateOf(taxPointDate: string, postedAt: number, filed: readonly {
+    to: string;
+    filedAt: number;
+}[]): string;

package/dist/entities/transaction/booking.d.ts

@@ -1,14 +1,14 @@
 import { BookingDocument } from '../../platform/bookkeeping';
-import { Company } from '../company/types';
-import { Transaction } from './types';
+import { SalesTransaction } from './types';
 /** The kinds that reach the books. A quote or an order books nothing. */
 export declare const BOOKABLE_KINDS: readonly ["invoice", "credit_note"];
-export declare function isBookable(tx: Pick<Transaction, "kindKey" | "issuedAt">): boolean;
+export declare function isBookable(tx: Pick<SalesTransaction, "kindKey" | "issuedAt">): boolean;
 /**
  * An issued invoice or credit note as the books need it (plan 039 datamodel §3.2). Pure: sales
  * owns the document, and this is the only shape of it that leaves the app.
  *
  * Headings and options carry no amount, so they are not lines here. A reverse charge or
  * exemption ticked on the document replaces every line's code, as it did when it was priced.
+ * The party is the one frozen at issue (review R2): no crm read, so nothing live in the hash.
  */
-export declare function bookingDocumentOf(tx: Transaction, company: Pick<Company, "id" | "name" | "vatNumber" | "kvkNumber"> | null, sourceApp?: string): BookingDocument;
+export declare function bookingDocumentOf(tx: SalesTransaction, sourceApp?: string): BookingDocument;

package/dist/entities/transaction/convert.d.ts

@@ -1,6 +1,6 @@
-import { Transaction } from './types';
+import { SalesTransaction } from './types';
 /** A transaction with `issuedAt` is frozen. One question, one answer, one place. */
-export declare function isFrozen(transaction: Pick<Transaction, "issuedAt">): boolean;
+export declare function isFrozen(transaction: Pick<SalesTransaction, "issuedAt">): boolean;
 /**
  * What a frozen transaction still accepts.
  *
@@ -12,30 +12,30 @@ export declare function isFrozen(transaction: Pick<Transaction, "issuedAt">): bo
  *
  * Everything else is a `BadRequestError`. Whoever wants to change a sent quote gets v2.
  */
-export declare const FROZEN_WRITABLE_FIELDS: readonly (keyof Transaction)[];
+export declare const FROZEN_WRITABLE_FIELDS: readonly (keyof SalesTransaction)[];
 /**
  * Issued, numbered kind, no number yet: the books number it and have not answered ("wordt
  * uitgegeven"). It cannot be sent to the customer until the number is on the paper.
  */
-export declare function awaitsNumber(tx: Pick<Transaction, "issuedAt" | "kindKey" | "number">): boolean;
+export declare function awaitsNumber(tx: Pick<SalesTransaction, "issuedAt" | "kindKey" | "number">): boolean;
 /**
  * What a save may set on a draft. `status` is not here: it moves through `issue` and the status
  * route, which check the transition and announce it.
  */
-export declare const DRAFT_FIELDS: readonly ["companyId", "contactId", "dealItemId", "title", "reference", "currency", "taxOverrideKey", "introText", "termsText", "expiresAt", "deliveredAt", "periodFrom", "periodTo", "paymentTerm", "billingAddressId", "lines"];
+export declare const DRAFT_FIELDS: readonly ["companyId", "contactId", "dealItemId", "title", "reference", "currency", "taxOverrideKey", "introText", "termsText", "expiresAt", "deliveredAt", "periodFrom", "periodTo", "paymentTerm", "billingAddressId", "deliveryAddressId", "invoiceTo", "lines"];
 /**
  * The draft fields a save may empty, named in `clear`. A list and not `null` in the body:
  * `invoke` strips `null`, so "empty this" never reaches the server any other way.
  */
-export declare const CLEARABLE_FIELDS: readonly ["contactId", "dealItemId", "title", "reference", "taxOverrideKey", "introText", "termsText", "expiresAt", "deliveredAt", "periodFrom", "periodTo", "billingAddressId"];
+export declare const CLEARABLE_FIELDS: readonly ["contactId", "dealItemId", "title", "reference", "taxOverrideKey", "introText", "termsText", "expiresAt", "deliveredAt", "periodFrom", "periodTo", "billingAddressId", "deliveryAddressId", "invoiceTo"];
 export type ClearableField = (typeof CLEARABLE_FIELDS)[number];
 /** The fields a draft carries over; the server owns id, organisation and author. */
-export type TransactionDraft = Omit<Transaction, "id" | "organizationId" | "createdBy" | "createdAt" | "updatedAt">;
+export type TransactionDraft = Omit<SalesTransaction, "id" | "organizationId" | "createdBy" | "createdAt" | "updatedAt">;
 /**
  * Whether `source` may become a `kindKey`: offered, a step the source's kind allows, and for a
  * correcting kind (a credit note) only from the issued document it corrects.
  */
-export declare function canConvert(source: Pick<Transaction, "kindKey" | "issuedAt">, kindKey: string): boolean;
+export declare function canConvert(source: Pick<SalesTransaction, "kindKey" | "issuedAt">, kindKey: string): boolean;
 /**
  * The conversion: quote -> order -> invoice -> credit note, as one function.
  *
@@ -47,7 +47,7 @@ export declare function canConvert(source: Pick<Transaction, "kindKey" | "issued
  * What is deliberately dropped: the number, the issue date, the due date, the file, the external
  * ids and the dunning history. Those belong to the document that went out, and this is a new one.
  */
-export declare function copyFrom(source: Transaction, kindKey: string): TransactionDraft;
+export declare function copyFrom(source: SalesTransaction, kindKey: string): TransactionDraft;
 /**
  * The next version of the same quote.
  *
@@ -56,4 +56,4 @@ export declare function copyFrom(source: Transaction, kindKey: string): Transact
  * afterwards: without this rule you have, a year from now, a quote that was changed after it was
  * signed and no way left to see that.
  */
-export declare function nextVersion(source: Transaction): TransactionDraft;
+export declare function nextVersion(source: SalesTransaction): TransactionDraft;

package/dist/entities/transaction/document.d.ts

@@ -4,7 +4,7 @@ import { TemplateCondition } from '../document-template/types';
 import { PricePer } from '../money/period-price';
 import { TaxRate } from '../money/tax';
 import { PostalAddress } from '../organization/types';
-import { Transaction } from './types';
+import { SalesTransaction } from './types';
 /**
  * The seam between a transaction and the paper it is printed on.
  *
@@ -22,6 +22,9 @@ export interface TransactionContextSources {
     /** The customer's postal address, for the recipient block. */
     companyAddress?: PostalAddress;
     contactName?: string;
+    /** The debtor's VAT number and debtor number, from the snapshot frozen at issue (review R2). */
+    companyVatNumber?: string;
+    companyNumber?: string;
     organizationName?: string;
     /** Who the recipient reads; drives which template row is picked. */
     locale?: string;
@@ -39,7 +42,7 @@ export interface TransactionContextSources {
  * quote would be one typo away from the customer. The shield on the way out of the server
  * (`transactionView`) is the second lock; this one is the first.
  */
-export declare function transactionContext(transaction: Transaction, sources?: TransactionContextSources): TemplateContext;
+export declare function transactionContext(transaction: SalesTransaction, sources?: TransactionContextSources): TemplateContext;
 /**
  * The blocks a template cannot write itself: the line table and the totals.
  *
@@ -50,13 +53,15 @@ export declare function transactionContext(transaction: Transaction, sources?: T
  * Amounts arrive already formatted. The blocks layer never computes; that is the whole reason a
  * totals row carries a string.
  */
-export declare function transactionSlots(transaction: Transaction, rates?: readonly TaxRate[], labels?: SlotLabels): DocumentSlots;
+export declare function transactionSlots(transaction: SalesTransaction, rates?: readonly TaxRate[], labels?: SlotLabels): DocumentSlots;
 export interface SlotLabels {
     description: string;
     /** Marks a line that is priced but not counted. */
     optional: string;
     quantity: string;
     unitPrice: string;
+    /** The line discount column, shown only when a line has one. */
+    discount: string;
     /** After a period price: "222,00 per jaar". */
     per: Record<PricePer, string>;
     /** A meter's display unit after a rated quantity: `minute` → "min". Unknown = the key. */

package/dist/entities/transaction/dunning.d.ts

@@ -1,5 +1,7 @@
 import { Cents } from '../money/money';
 import { ReceivableRow } from './receivable';
+/** ponytail: one fixed grace for every administration; a policy field when someone asks. */
+export declare const UNCOLLECTED_AFTER_DAYS = 7;
 /** One step of the schedule. Level 1 counts from the due day, every later one from the last sent. */
 export interface DunningStep {
     level: number;
@@ -30,8 +32,17 @@ export interface DunningDue {
  * every step went out (a person takes over), or `null` when nothing is due yet.
  */
 export declare function dunningStateOf(row: ReceivableRow, policy: DunningPolicy, today: string): DunningDue | "done" | null;
-/** The whole run: what is due now per step, and what waits for a person. */
+/**
+ * A debit, pin or cash invoice still open `UNCOLLECTED_AFTER_DAYS` past its due day: nobody
+ * collects it (no direct-debit run exists yet) and nobody may remind, so a person looks.
+ */
+export declare const isUncollected: (row: ReceivableRow, today: string) => boolean;
+/**
+ * The whole run: what is due now per step, what waits for a person after the last step, and the
+ * collected-by-us invoices that never came in.
+ */
 export declare function dunningRunOf(rows: readonly ReceivableRow[], policy: DunningPolicy, today: string): {
     due: DunningDue[];
     waiting: ReceivableRow[];
+    uncollected: ReceivableRow[];
 };

package/dist/entities/transaction/facets.test.d.ts

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

package/dist/entities/transaction/keys.d.ts

@@ -46,4 +46,7 @@ export declare function transactionDossierKeys(transaction: {
     companyId?: string;
     contactId?: string;
     dealItemId?: string;
+    invoiceTo?: {
+        companyId: string;
+    };
 }): string[];