@opencxh/domain 1.302.0 → 1.303.0

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

@@ -11,7 +11,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,19 +39,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?: {
+    provider?: {
         app: string;
         offer: string;
     };
@@ -73,6 +77,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 +89,43 @@ export interface PurchaseLine extends TransactionLine {
     /** Matched to supplier invoices (fase 7). */
     billedQty: number;
     use: PurchaseUse;
-    dimensions?: {
-        costCenterId?: string;
-        projectId?: string;
-    };
-    /** Absent = `purchase`. A change or an end points at the contract line it is about. */
-    action?: ProvisioningAction;
-    contractLine?: {
-        contractId: string;
-        lineId: string;
+    /** What the supplier confirmed (Ingram `quantity_confirmed`, `quantity_back_ordered`). */
+    confirmation?: {
+        quantity: number;
+        backorder?: number;
+        promisedAt?: number;
     };
-    /** 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 +135,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 +150,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 +179,7 @@ export interface GoodsReceiptLine {
 export interface GoodsReceipt {
     id: string;
     organizationId: string;
-    businessEntityId?: string;
+    businessEntityId: string;
     movement: "in" | "return";
     purchaseOrderId: string;
     supplierCompanyId: string;
@@ -164,5 +190,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/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[];

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

@@ -1,4 +1,5 @@
-import { TransactionStatus } from './types';
+import { PurchaseStatus } from '../purchase/types';
+import { SalesStatus } from './types';
 /**
  * A kind is a row of flags, not a subclass.
  *
@@ -11,7 +12,7 @@ import { TransactionStatus } from './types';
  * app, on the same type and its own table. A flag that is always `out` in one app and always `in`
  * in the other is an app boundary, not a flag.
  */
-export interface TransactionKind {
+export interface TransactionKind<S extends string = string> {
     key: string;
     /** i18n key, not text. For a screen that has `t()`. */
     label: string;
@@ -23,7 +24,7 @@ export interface TransactionKind {
     numbered: boolean;
     /** Invert amounts: a credit note is an invoice with a minus sign. */
     signFlip: boolean;
-    statuses: readonly TransactionStatus[];
+    statuses: readonly S[];
     /**
      * The route segment this kind lives under: `quotes`, `orders`, `invoices`.
      *
@@ -38,13 +39,13 @@ export interface TransactionKind {
      * handler writes `status: "sent"` for everything, and `sent` is not in the status list of an
      * invoice or a credit note.
      */
-    issuedStatus: TransactionStatus;
+    issuedStatus: S;
     /**
      * The answers a person may give after issuing, per status. `draft -> issuedStatus` is not in
      * here: that move is `issue`, with its gate and its number. Walking back one step is allowed —
      * a mis-click on "accepted" must not need a new version.
      */
-    transitions: Partial<Record<TransactionStatus, readonly TransactionStatus[]>>;
+    transitions: Partial<Record<S, readonly S[]>>;
     /** What this kind may become through `convert`. A revision of the same kind is `version`. */
     convertsTo: readonly string[];
     /**
@@ -54,13 +55,13 @@ export interface TransactionKind {
     credits?: string;
 }
 /** What `apps/sales` issues. Another app's kinds live in their own list, same shape. */
-export declare const SALES_KINDS: readonly TransactionKind[];
+export declare const SALES_KINDS: readonly TransactionKind<SalesStatus>[];
 /**
  * Every app's kinds, for looking one up by key. Keys are unique across apps (`invoice` is sales',
  * `purchase_order` will be purchase's), so a key alone names its kind. Never enumerate this in an
  * app: sales lists {@link SALES_KINDS}, or a purchase kind claims sales scopes and series.
  */
-export declare const TRANSACTION_KINDS: readonly TransactionKind[];
+export declare const TRANSACTION_KINDS: readonly (TransactionKind<SalesStatus> | TransactionKind<PurchaseStatus>)[];
 /**
  * Which kinds the app actually offers today.
  *
@@ -84,7 +85,7 @@ export declare function listedTransactionKinds(): TransactionKind[];
  */
 export declare function transactionKind(key: string): TransactionKind;
 /** Dutch status names, for the same server-side readers as {@link TransactionKind.name}. */
-export declare const STATUS_NAMES: Record<TransactionStatus, string>;
+export declare const STATUS_NAMES: Record<SalesStatus | PurchaseStatus, string>;
 /** Where a person may move this document from its current status. Empty on a draft's issue. */
-export declare function nextStatuses(kindKey: string, from: TransactionStatus): readonly TransactionStatus[];
-export declare function canTransition(kindKey: string, from: TransactionStatus, to: TransactionStatus): boolean;
+export declare function nextStatuses<S extends string>(kindKey: string, from: S): readonly S[];
+export declare function canTransition(kindKey: string, from: string, to: string): boolean;

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

@@ -1,6 +1,7 @@
 import { SettlementState } from '../../platform/bookkeeping';
 import { Cents } from '../money/money';
-import { Transaction } from './types';
+import { PaymentTermMethod } from './payment-term';
+import { SalesTransaction } from './types';
 /** One open invoice as "Openstaand" shows it. */
 export interface ReceivableRow {
     id: string;
@@ -18,11 +19,13 @@ export interface ReceivableRow {
     /** The highest dunning step sent, 0 for none. */
     dunningLevel: number;
     lastDunningAt?: number;
+    /** How it is paid, from the copied payment condition: a direct debit is not chased. */
+    paymentMethod?: PaymentTermMethod;
 }
 export declare const AGING_BUCKETS: readonly ["current", "d1_30", "d31_60", "d61_90", "d90_plus"];
 export type AgingBucket = (typeof AGING_BUCKETS)[number];
 /** `null` for a row that is not open (a draft, cancelled, or paid). */
-export declare function receivableRowOf(tx: Transaction, today: string): ReceivableRow | null;
+export declare function receivableRowOf(tx: SalesTransaction, today: string): ReceivableRow | null;
 export declare function agingBucketOf(overdueDays: number): AgingBucket;
 /** Open amount and count per bucket, every bucket present so the strip never jumps. */
 export declare function agingOf(rows: readonly ReceivableRow[]): Record<AgingBucket, {

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

@@ -1,20 +1,20 @@
 import { SettledNotice, SettlementState } from '../../platform/bookkeeping';
-import { Transaction } from './types';
+import { SalesTransaction } from './types';
 /**
  * Payment and overdue as two axes beside the lifecycle (plan 039 datamodel §2.3): an invoice can
  * be partly paid and overdue at once. Pure, so the list, the job and the notice agree.
  */
 /** Unpaid until someone or something says otherwise. */
-export declare function paymentStateOf(tx: Pick<Transaction, "settlement">): SettlementState;
-export declare function isSettled(tx: Pick<Transaction, "settlement">): boolean;
+export declare function paymentStateOf(tx: Pick<SalesTransaction, "settlement">): SettlementState;
+export declare function isSettled(tx: Pick<SalesTransaction, "settlement">): boolean;
 /** Open means: went out, is still live, and not paid. A draft or a cancelled document is not. */
-export declare function isOutstanding(tx: Pick<Transaction, "status" | "issuedAt" | "settlement">): boolean;
+export declare function isOutstanding(tx: Pick<SalesTransaction, "status" | "issuedAt" | "settlement">): boolean;
 /** Overdue on `today` (`"2026-09-26"`): outstanding and past its due day. */
-export declare function isOverdueOn(tx: Pick<Transaction, "status" | "issuedAt" | "settlement" | "dueAt">, today: string): boolean;
+export declare function isOverdueOn(tx: Pick<SalesTransaction, "status" | "issuedAt" | "settlement" | "dueAt">, today: string): boolean;
 /**
  * What a notice from the books changes on the document, or `null` when it changes nothing. A
  * notice older than what we hold is ignored; posting facts only ever fill in, never overwrite.
  */
-export declare function settlementPatch(tx: Pick<Transaction, "settlement" | "postedAt" | "externalIds" | "number">, notice: SettledNotice): Partial<Transaction> | null;
+export declare function settlementPatch(tx: Pick<SalesTransaction, "settlement" | "postedAt" | "externalIds" | "number">, notice: SettledNotice): Partial<SalesTransaction> | null;
 /** A person ticking it off by hand, when no books are connected. */
-export declare function manualSettlement(tx: Pick<Transaction, "totals">, state: "unpaid" | "paid", now: number): NonNullable<Transaction["settlement"]>;
+export declare function manualSettlement(tx: Pick<SalesTransaction, "totals">, state: "unpaid" | "paid", now: number): NonNullable<SalesTransaction["settlement"]>;