@opencxh/domain 1.302.0 → 1.304.0

package/dist/entities/agreement/from-quote.d.ts

@@ -1,18 +1,18 @@
-import { Transaction, TransactionLine } from '../transaction/types';
+import { SalesLine, SalesTransaction } from '../transaction/types';
 import { SaveAgreementRequest } from './types';
 /** A line that runs every period: a product line priced per month, quarter or year. */
-export declare function isRecurringLine(line: TransactionLine): boolean;
+export declare function isRecurringLine(line: SalesLine): boolean;
 /**
- * An accepted quote as an agreement: its recurring lines, each with its price as a snapshot —
- * what the customer accepted, not what the ladder says on some later day. One-off lines stay on
- * the quote (they are invoiced from it).
+ * An accepted quote as an agreement: its recurring lines, each with the accepted price as its
+ * first price from the agreement's start — what the customer accepted, not what the ladder says
+ * on some later day — and the quote's invoice head. One-off lines stay on the quote.
  *
  * ponytail: a line discount is folded into the unit price, rounded per unit; a discount field on
- * `LinePrice` if a cent per unit ever matters.
+ * `AgreedPrice` if a cent per unit ever matters.
  */
-export declare function agreementFromQuote(quote: Transaction, startsAt: number): SaveAgreementRequest;
+export declare function agreementFromQuote(quote: SalesTransaction, startsAt: number): SaveAgreementRequest;
 /**
  * What a quote is worth to the deal, excluding VAT: the one-off lines once, the recurring ones
  * over a year (the term a quote does not state). Optional lines count for nothing.
  */
-export declare function dealValueCents(quote: Pick<Transaction, "lines">): number;
+export declare function dealValueCents(quote: Pick<SalesTransaction, "lines">): number;

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

@@ -1,5 +1,7 @@
 export * from './from-quote';
+export * from './invoice-head';
 export * from './lifecycle';
 export * from './period';
+export * from './prices';
 export * from './schedule';
 export * from './types';

package/dist/entities/agreement/invoice-head.d.ts

@@ -0,0 +1,21 @@
+import { CompanyRole } from '../company/role';
+import { SalesTransaction } from '../transaction/types';
+import { AgreementInvoice } from './types';
+/** The part of an invoice that says who pays, where, on what condition and under what reference. */
+export type InvoiceHead = Partial<Pick<SalesTransaction, "contactId" | "invoiceTo" | "billingAddressId" | "paymentTerm" | "reference">>;
+/**
+ * The invoice head, field by field: what the document asks, else its agreement's, else the
+ * customer role's. Who pays (recipient, contact, address) is one choice — a contact or address
+ * of the agreement's payer never lands on a document that names another. The role has only a
+ * payment term; `saveDraft` applies it when `paymentTermCode` comes from there.
+ */
+export declare function partyTerms(layers: {
+    role?: Pick<CompanyRole, "paymentTermKey">;
+    agreement?: AgreementInvoice;
+    asked?: AgreementInvoice;
+}): {
+    head: InvoiceHead;
+    paymentTermCode?: string;
+};
+/** A quote's head as the agreement keeps it: the run puts it on every invoice it writes. */
+export declare function invoiceFromQuote(quote: SalesTransaction): AgreementInvoice;

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

@@ -33,6 +33,16 @@ export declare function noticeDeadline(start: number, commitment: Commitment | u
  * Not the same as stopping the service today — that is a different decision.
  */
 export declare function effectiveEndAt(start: number, commitment: Commitment | undefined, noticeAt: number): number;
+/**
+ * Where a purchase that must cover a sale until `saleEnd` can end, with notice given now: the
+ * first term end on or after the sale's end — or, when its notice deadline has passed, the one
+ * after (`nextTerm`). Never before the sale ends: the customer still uses it (plan 047 §3).
+ */
+export declare function coverEndAt(start: number, commitment: Commitment | undefined, saleEnd: number, now: number): {
+    endsAt: number;
+    deadline?: number;
+    nextTerm?: boolean;
+};
 /** The whole agreement: the latest effective end over the lines still running. */
 export declare function agreementEffectiveEnd(agreement: Pick<Agreement, "startsAt" | "endsAt" | "commitment" | "lines">, noticeAt: number): number;
 /** A billed line may only get (or move) its end; anything else must be a successor. */

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

@@ -18,6 +18,14 @@ export declare function lineTerm(agreement: Pick<Agreement, "startsAt" | "endsAt
     from: number;
     to?: number;
 };
+/**
+ * When a line bills: its term, from the day it first ran when billing waits for that (plan 047
+ * §10.2). `null` = not yet: nothing to bill. `delivery` follows with goods (047 step 4).
+ */
+export declare function billingTerm(agreement: Pick<Agreement, "startsAt" | "endsAt">, line: Pick<AgreementLine, "startsAt" | "endsAt" | "billingStart" | "activatedAt">): {
+    from: number;
+    to?: number;
+} | null;
 /** The part of `period` a term covers, or `null` when they do not meet. */
 export declare function overlap(term: {
     from: number;

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

@@ -0,0 +1,43 @@
+import { Cents } from '../money/money';
+import { BilledLine } from './schedule';
+import { AgreedPrice, AgreementLine } from './types';
+/**
+ * The price that holds on `at`: the latest `from` at or before it. Before the first one the first
+ * holds — it starts with the line. `undefined` = no agreed price, the ladder decides.
+ */
+export declare function priceAt(prices: readonly AgreedPrice[] | undefined, at: number): AgreedPrice | undefined;
+/** The first price that starts after `at`: "€ 20,30 from 1 Jan 2027". */
+export declare function nextPrice(prices: readonly AgreedPrice[] | undefined, at: number): AgreedPrice | undefined;
+/** `entry` in the list: replaces one on the same day, kept ascending. */
+export declare function withPrice(prices: readonly AgreedPrice[] | undefined, entry: AgreedPrice): AgreedPrice[];
+/** Per agreement line, the exclusive end of the last window an invoice billed. */
+export declare function billedThroughOf(billed: readonly BilledLine[]): Record<string, number>;
+/**
+ * Whether `after` changes a price that billed windows were priced at: anything starting before
+ * `billedThrough`. A new price starts after the last billed day (review 5a-6, besluit 2).
+ */
+export declare function changesBilledPrice(before: readonly AgreedPrice[] | undefined, after: readonly AgreedPrice[] | undefined, billedThrough: number | undefined): boolean;
+/** What indexing did to one line, for the modal's preview. */
+export interface IndexedLine {
+    lineId: string;
+    /** Not indexed: it follows the ladder (`ladder`), or is priced per record (`rated`). */
+    skipped?: "ladder" | "rated";
+    /** The price the day before `from`. */
+    base?: Cents;
+    next?: Cents;
+    /** A price already planned on `from`, replaced. */
+    replaces?: Cents;
+}
+/**
+ * Index every agreed price by `percent` from `from`: one new date per line, never a split. The
+ * base is the price that holds the day before, rounded half up to a cent. Lines on the ladder or
+ * priced per record are skipped — those prices are indexed in the price list or the rate card.
+ */
+export declare function indexPrices(lines: readonly AgreementLine[], change: {
+    from: number;
+    percent: number;
+    ratedProductIds?: readonly string[];
+}): {
+    lines: AgreementLine[];
+    results: IndexedLine[];
+};

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

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

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

@@ -1,6 +1,7 @@
 import { PriceBand } from '../catalog/rating';
 import { Cents } from '../money/money';
 import { PricePer } from '../money/period-price';
+import { TransactionPaymentTerm } from '../transaction/payment-term';
 /**
  * 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).
@@ -13,7 +14,11 @@ export interface Agreement {
     organizationId: string;
     title: string;
     companyId: string;
-    businessEntityId?: string;
+    /** What every invoice of this agreement carries in its head; filled from the quote. */
+    invoice?: AgreementInvoice;
+    /** From the administration's `agreement` series, drawn when it first becomes active. */
+    number?: string;
+    businessEntityId: string;
     currency: string;
     status: AgreementStatus;
     /** Epoch ms. The first period starts on the interval boundary at or before this. */
@@ -32,7 +37,6 @@ export interface Agreement {
      * records still arrive, and both land on the same run.
      */
     graceDays: number;
-    paymentTermKey?: string;
     /** "Reverse charge / exempt" for this customer: every invoice the run writes carries it. */
     taxOverrideKey?: string;
     /** The default commitment of its lines; a line may carry its own. Absent = cancel any time. */
@@ -61,13 +65,38 @@ export interface Commitment {
     noticeDays: number;
     renew: "term" | "month" | "none";
 }
-/** A price fixed on the line when it was agreed, instead of the ladder at billing time. */
+/**
+ * The head the run puts on each invoice (review 5a-5). `contactId` is a contact of whoever pays:
+ * the `invoiceTo` company when there is one, else the customer. A change applies from the next
+ * invoice; an issued one froze its own.
+ */
+export interface AgreementInvoice {
+    contactId?: string;
+    /** The holding that pays for its daughter. Its contact is `contactId`. */
+    invoiceTo?: {
+        companyId: string;
+    };
+    /** A crm address of whoever pays; absent = their standard billing address. */
+    billingAddressId?: string;
+    paymentTerm?: TransactionPaymentTerm;
+    /** The customer's PO number: on every invoice of this agreement. */
+    reference?: string;
+}
+/** A price fixed on a supplier contract line when it was made (purchase). Per its `unitKey`. */
 export interface LinePrice {
-    /** Per the line's `unitKey`. */
     cents: Cents;
     currency: string;
     per?: PricePer;
 }
+/**
+ * The price agreed on a line from a day on (D1): each holds until the next one starts. In the
+ * agreement's currency, per the line's `unitKey`; `per` absent = the product's price period.
+ */
+export interface AgreedPrice {
+    from: number;
+    cents: Cents;
+    per?: PricePer;
+}
 export type AgreementInterval = "month" | "quarter" | "year";
 export interface AgreementLine {
     id: string;
@@ -84,14 +113,16 @@ export interface AgreementLine {
      * Absent = the line's own id.
      */
     seriesId?: string;
-    /** Agreed price, snapshot (from the quote). Absent = the price ladder on the window's day. */
-    price?: LinePrice;
-    /** Overrides the agreement's commitment for this line. */
-    commitment?: Commitment;
     /**
-     * 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.
+     * What this customer pays for this line, ascending on `from` (D1). A price change is a new
+     * date, never a split. Empty = the price ladder on the window's day.
      */
+    prices?: AgreedPrice[];
+    /** A line priced per record: its rate card. Absent = the ladder's (customer, else product). */
+    rateCardId?: string;
+    /** Overrides the agreement's commitment for this line. */
+    commitment?: Commitment;
+    /** Where the quantity comes from. Per unit or per record is the product's `pricing`. */
     quantity: LineQuantity;
     /** Taken off the quantity before the price: "the first 5 are included". */
     included?: number;
@@ -106,8 +137,22 @@ export interface AgreementLine {
     billing?: LineBilling;
     /** A fixed line's own rhythm; never shorter than the agreement's. Absent = the agreement's. */
     every?: LineRhythm;
+    /**
+     * When billing starts (plan 047 §10.2): on its dates (`date`, or absent), or only once what it
+     * sells runs (`activation`: the first time fulfilment sees it active). A new line takes its
+     * product's {@link Product.billingStart}. `delivery` follows with goods sold on an agreement.
+     */
+    billingStart?: BillingStart;
+    /** Set by fulfilment, never by a person: the first day it ran. A resume does not move it. */
+    activatedAt?: number;
+    /** From the quote line (plan 053): see {@link SalesLine.configurationId}. */
+    configurationId?: string;
+    /** A sub-line of that configuration: the answer it comes from (see `SalesLine.optionKey`). */
+    optionKey?: string;
 }
 export type LineBilling = "advance" | "arrears";
+/** When a line starts billing: on its dates, or once what it sells runs (047 §10.2). */
+export type BillingStart = "date" | "activation";
 export type LineRhythm = AgreementInterval | "once";
 export type LineQuantity = {
     from: "fixed";

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

@@ -37,8 +37,22 @@ export interface MatchContext {
     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;
+/**
+ * `Reconciliation.on`: the latest day of every line it matches (Exact `EndDate`, "the highest
+ * invoice date of all matched"). A prepayment on 15-12 for an invoice of 05-01 settles on 05-01,
+ * so on 31-12 it is still open as a prepayment.
+ */
+export declare const reconciledOn: (days: readonly string[]) => string;
+/**
+ * Whether a reconciliation settles on `asOf` (`YYYY-MM-DD`): in effect by then and not yet undone.
+ * Without a day: whether it is active now.
+ */
+export declare function settlesOn(rec: Pick<Reconciliation, "status" | "on" | "reversal">, asOf?: string): boolean;
+/**
+ * What is left of an item: its amount minus every allocation on it that settles on `asOf` (now,
+ * without one). Computed, never stored.
+ */
+export declare function openCentsOf(itemKey: string, amountCents: Cents, reconciliations: readonly Pick<Reconciliation, "status" | "allocations" | "on" | "reversal">[], asOf?: string): 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;
 /**

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

@@ -32,6 +32,11 @@ export interface BankImport {
     /** What the statement says. A difference with our balance is a signal, never a silent fix. */
     statementOpeningCents?: Cents;
     statementClosingCents?: Cents;
+    /**
+     * The balances do not add up: `sum` = opening + lines ≠ closing, `gap` = the opening is not the
+     * previous statement's closing (a statement missed or imported twice).
+     */
+    balanceIssue?: "sum" | "gap";
     lineCount: number;
     importedBy: string;
     createdAt?: number;
@@ -62,6 +67,8 @@ export interface ParsedStatement {
     to: string;
     openingCents?: Cents;
     closingCents?: Cents;
+    /** Σ of the lines: sent with the header, because the lines themselves arrive in chunks. */
+    movementCents?: Cents;
     lines: ParsedBankLine[];
 }
 /** What a bank line is paired with. The pair lives on the line only; nothing points back. */
@@ -188,6 +195,11 @@ export interface Reconciliation {
     /** Flat and indexed: which reconciliations touch this item is an `$in` on this field. */
     itemKeys: string[];
     status: "active" | "reversed";
+    /**
+     * The day it takes effect (`YYYY-MM-DD`): the bank or payment day, not the click. "What was open
+     * on 31-12" is rebuilt from this (Exact: `EndPeriod` on the open item).
+     */
+    on: string;
     origin: {
         via: "exact" | "rule" | "manual";
         ruleId?: string;

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

@@ -2,6 +2,7 @@ import { BookingDocument } from '../../platform/bookkeeping';
 import { Cents } from '../money/money';
 import { TaxRateKind } from '../money/tax';
 import { MatchAllocation, MatchVerdict } from '../purchase/match';
+import { LineDimensions } from '../transaction/types';
 import { WorkQueueItem } from './types';
 /**
  * A receipt or purchase invoice, as finance holds it until it is booked (plan 039 datamodel §6.4).
@@ -60,6 +61,11 @@ export interface Receipt {
         grossCents: Cents;
     };
     status: ReceiptStatus;
+    /**
+     * Another receipt of this supplier with the same invoice number, not rejected: the same invoice
+     * by mail and by upload. Set by the server; `""` once it is not any more.
+     */
+    duplicateOf?: string;
     /** 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). */
@@ -90,6 +96,8 @@ export interface ReceiptFields {
     supplierVatNumber?: Field<string>;
     supplierIban?: Field<string>;
     invoiceNumber?: Field<string>;
+    /** The reference the supplier wants with the payment (betalingskenmerk), when printed. */
+    paymentReference?: Field<string>;
     /** `"2026-09-24"`. */
     issueDate?: Field<string>;
     dueDate?: Field<string>;
@@ -103,13 +111,16 @@ export interface ReceiptFields {
 export interface ReceiptMatch {
     allocations: MatchAllocation[];
     unmatched: string[];
+    /** Lines that match in another currency: the receipt's rate first (045 F). */
+    needsRate?: string[];
     verdict: MatchVerdict;
     /** The one administration every target sits in; absent when mixed or nothing matched. */
     businessEntityId?: string;
     mixed: boolean;
 }
 /** One printed line of a supplier invoice, with how it books. */
-export interface ReceiptLine {
+/** The B1 dimensions sit flat on the line: `customerCompanyId` is whose cost this is. */
+export interface ReceiptLine extends LineDimensions {
     /** Stable for the line's life; what a treatment or a match points at (`receipt:<id>#<lineId>`). */
     id?: string;
     description?: string;
@@ -133,6 +144,8 @@ export interface ReceiptLine {
     /** The account in the target books (`LedgerOption.key`). */
     accountKey?: string;
     aiSuggested?: boolean;
+    /** Where a proposed account came from: the article's own rule or its ledger group's (045 F-3). */
+    accountFrom?: "product" | "group";
     /** Absent = a cost. Own books only: the line becomes a fixed asset or is spread over months. */
     treatment?: ReceiptLineTreatment;
     /**
@@ -140,11 +153,33 @@ export interface ReceiptLine {
      * customer and never a fixed asset, whatever the amount. Set by the order match or a person.
      */
     use?: "own" | "resale";
-    /** Whose cost this is: reaches the journal line as a dimension, for margin per customer. */
-    customerCompanyId?: string;
     /** The product it was ordered as (from the match): posting rules on product apply. */
     productId?: string;
+    /** The article's ledger group (from the match): the rule on the group picks the account. */
+    ledgerCategoryKey?: string;
+    /**
+     * One printed line for more than one destination — a collective invoice for A and B (plan 045
+     * F). The line stays as printed; the books take one line per share. The shares add up to the
+     * line exactly. Absent = one destination, on the line itself.
+     */
+    allocations?: ReceiptLineShare[];
+}
+/** Whose part of a printed line, and what it costs: the dimensions of what it was ordered for. */
+export interface ReceiptLineShare extends LineDimensions {
+    netCents: Cents;
+    taxCents: Cents;
+    /** A contract period the invoice did not print, as the line's `period`. */
+    period?: {
+        from: string;
+        to: string;
+    };
 }
+/**
+ * A printed line with what the match says it paid for (045 F-2): the product and its ledger
+ * group, and where the cost goes. One destination sits on the line; two or more become shares,
+ * split by what the match allotted each and with the VAT in the same proportion.
+ */
+export declare function matchedLine(line: ReceiptLine, parts: readonly MatchAllocation[]): ReceiptLine;
 /**
  * What a line becomes besides its booking (plan 041 §4): a fixed asset in a group (its account
  * is then the group's cost account), or a prepaid cost released over months (its account is
@@ -176,17 +211,21 @@ export declare function suggestTreatments(lines: readonly ReceiptLine[], groups:
 }[], thresholdCents: number | undefined): ReceiptLine[];
 /** 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" | "asset_without_group" | "spread_without_months";
+export type ReceiptProblem = "no_supplier" | "no_date" | "no_lines" | "no_account" | "asset_without_group" | "spread_without_months" | "duplicate";
 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. */
+/**
+ * What still stands between this receipt and the books. Empty = it can be confirmed. A duplicate
+ * is no problem here but a warning (plan 052 point 4): it keeps the receipt from being booked
+ * without a person, and a person may still book it.
+ */
 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" | "match">): WorkQueueItem["group"] | null;
+export declare function receiptGroupOf(receipt: Pick<Receipt, "fields" | "lines" | "status" | "match" | "duplicateOf">): WorkQueueItem["group"] | null;
 /**
  * The printed lines grouped as the books take them: one per account, VAT rate and customer, the
  * descriptions joined. Grouped here, at booking, and never stored — what is booked is always

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

@@ -12,7 +12,7 @@ export interface BookkeepingBinding {
     app: string;
     /** `ManagedAccount.id` of the connection; empty for our own books. */
     accountId?: string;
-    /** Mapping onto an external package's accounts. Our own books use `PostingRule` instead. */
+    /** Rules onto the target books' accounts: a package's keys, or our own account ids. */
     ledgerMapping?: LedgerMappingRule[];
     /** Documents issued before this day stay with the previous books. */
     activeFrom: string;
@@ -31,7 +31,6 @@ export interface LedgerMappingRule {
     direction?: "sale" | "purchase";
     /** `BookkeepingDescribe.ledgerOptions[].key`. */
     targetKey: string;
-    externalTaxCode?: string;
 }
 /**
  * pending: to do, or to do again.

package/dist/entities/business-entity/types.d.ts

@@ -73,6 +73,14 @@ export interface BusinessEntity {
      */
     firstDebtorNumber?: number;
     firstCreditorNumber?: number;
+    /**
+     * How far a supplier invoice may differ from its order or contract and still book without a
+     * person (plan 045 F-3): the larger of the two counts. Absent or a part absent = 1 % / € 1,00.
+     */
+    matchTolerance?: {
+        percent?: number;
+        cents?: number;
+    };
     /** The one a new document lands on. Exactly one row carries it. */
     isDefault?: boolean;
     /** Archived, never deleted: an issued quote names the entity it went out as. */
@@ -86,23 +94,11 @@ export type LegalForm = "bv" | "nv" | "eenmanszaak" | "vof" | "maatschap" | "sti
 export declare const LEGAL_FORMS: readonly LegalForm[];
 /** What {@link businessEntitySender} reads. Structural, so the document layer keeps pointing here. */
 export type BusinessEntityLike = Pick<BusinessEntity, "name" | "address" | "vatNumber" | "kvkNumber" | "iban" | "logo" | "footerText">;
-/**
- * Does this row belong to this entity?
- *
- * Master data is owned by **exactly one** entity. An empty owner means the **default** entity, so
- * rows written before entities existed stay where they were without a backfill.
- */
-export declare function belongsToEntity(rowEntityId: string | undefined, entityId: string, isDefaultEntity: boolean): boolean;
-/**
- * The `businessEntityId` values that belong to this entity, as a query filter:
- * `{ businessEntityId: { $in: entityOwnerIds(entity) } }`. Same rule as {@link belongsToEntity};
- * it works as a filter because every sales schema defaults the column to `""`, never unset.
- */
-export declare function entityOwnerIds(entity: Pick<BusinessEntity, "id" | "isDefault">): string[];
 /**
  * A shared table with per-entity overrides: rows with an empty `businessEntityId` first, then the
- * entity's own over them by `key`. How VAT rates and payment terms both work — a Belgian sister
- * needs `low` at 6, not `low` hidden.
+ * entity's own over them by `key` — a Belgian sister needs `low` at 6, not `low` hidden. The only
+ * place `""` means anything: "shared", on master data (tax codes, payment terms, dunning). A document,
+ * booking or item always carries a real id (review 5a-4).
  */
 export declare function shadowByKey<T extends {
     businessEntityId?: string;

package/dist/entities/catalog/pricing.d.ts

@@ -1,22 +1,23 @@
 import { Cents } from '../money/money';
 import { PricePer } from '../money/period-price';
-import { TransactionLine } from '../transaction/types';
+import { SalesLine } from '../transaction/types';
 import { PriceRule, SellableProduct } from './types';
 /** What the ladder reads of an article: its identity and sales' price row. */
-export type PricedProduct = Pick<SellableProduct, "id" | "categoryKey" | "listPriceCents" | "currency" | "pricePer" | "rateCardId">;
+export type PricedProduct = Pick<SellableProduct, "id" | "categoryKey" | "listPriceCents" | "currency" | "pricePer" | "rateCardId" | "markupPercent">;
 /**
  * The ladder: the most specific rule wins, whole. No sum, no stacking.
  *
  * | Rank | Rule | Source |
  * |---|---|---|
- * | 1 | contract + product | `contract` |
- * | 2 | customer + product | `customer` |
- * | 3 | customer + category | `customer_category` |
- * | 4 | segment + product | `segment` |
- * | 5 | segment + category | `segment_category` |
- * | 6 | everyone + product | `everyone` |
- * | 7 | everyone + category | `everyone_category` |
- * | 8 | the product's list price | `list` |
+ * | 1 | customer + product | `customer` |
+ * | 2 | customer + category | `customer_category` |
+ * | 3 | segment + product | `segment` |
+ * | 4 | segment + category | `segment_category` |
+ * | 5 | everyone + product | `everyone` |
+ * | 6 | everyone + category | `everyone_category` |
+ * | 7 | the product's list price | `list` |
+ *
+ * No contract rung (D1): a price agreed in an agreement lives on its line (`prices[]`).
  *
  * A tier (`minQuantity`) is not a rung of its own but a tie-break within one: of the rules that
  * pass, the highest threshold that the quantity reaches wins, and the source then reads `tier`
@@ -25,11 +26,12 @@ export type PricedProduct = Pick<SellableProduct, "id" | "categoryKey" | "listPr
 export interface PriceContext {
     companyId?: string;
     segmentKey?: string;
-    contractId?: string;
     /** In the article's **base** unit: 2 boxes of 10 reach a tier "from 20" (plan 046 #10). */
     quantity: number;
     /** Epoch ms; the validity window is judged against this, not against "now". */
     at: number;
+    /** What one unit costs us, for a `markupPercent` article (from the line's configuration). */
+    costCents?: Cents;
 }
 /** Amount, currency and period travel together: € 222 means nothing without "per year". */
 export interface ResolvedPrice {
@@ -62,4 +64,4 @@ export declare const MISSING_PRICE_SOURCE = "missing";
  * a tier or an agreement may now apply. A typed price stays, and so does a line whose product
  * is no longer in `products`.
  */
-export declare function repriceLines(lines: readonly TransactionLine[], products: readonly PricedProduct[], rules: readonly PriceRule[], ctx: Omit<PriceContext, "quantity">): TransactionLine[];
+export declare function repriceLines(lines: readonly SalesLine[], products: readonly PricedProduct[], rules: readonly PriceRule[], ctx: Omit<PriceContext, "quantity">): SalesLine[];

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

@@ -36,6 +36,11 @@ export interface Product {
     kind: ProductKind;
     /** Serial or batch numbers on receipt and delivery. Absent = none; goods only. */
     tracking?: ProductTracking;
+    /**
+     * When an agreement line for it starts billing, as a default the line takes (047 vraag 2): on
+     * its dates, or once it runs — a number or a licence that counts only when it works.
+     */
+    billingStart?: "date" | "activation";
     /** The base unit everything counts in: stock, deliveries, allocations. Locked once used. */
     unitKey: string;
     /** Other units it comes in: a roll of 500 m, a box of 10. See {@link toBaseUnits}. */
@@ -142,6 +147,11 @@ export interface SalesProduct {
     pricing?: ProductPricing;
     /** The default card of a `rated` product. A price agreement may name another. */
     rateCardId?: string;
+    /**
+     * Priced as cost plus this percentage instead of a list price (plan 053: an extra EVC costs us
+     * anything from € 4 to € 397). The line's cost comes from its configuration; no cost = no price.
+     */
+    markupPercent?: number;
     /** The unit a new line starts in (a box); absent = the base unit. */
     unitKey?: string;
     updatedAt?: number;
@@ -172,7 +182,13 @@ export type ProductPricing = "unit" | "rated";
 export declare const FIXED_UNITS: readonly ["piece", "hour", "day", "month", "km", "license", "minute", "kg", "ton", "m", "m2", "m3", "liter", "box", "roll", "pallet", "pack"];
 export type FixedUnit = (typeof FIXED_UNITS)[number];
 /**
- * A price for a customer, a segment or a contract.
+ * Whether a quantity in this unit may have a fraction. Counted units (piece, licence, box, an
+ * article's own pack) take whole numbers (Exact: `IsFractionAllowedItem`, here per unit).
+ */
+export declare const allowsFraction: (unitKey: string) => boolean;
+/**
+ * A price for a customer, a segment or everyone. A price agreed in an agreement is not one: it
+ * lives on the agreement line (D1).
  *
  * Deliberately no price expression language: no formulas, no conditions, no ordering field. The
  * moment a price cannot be explained to the customer it is the wrong price.
@@ -201,13 +217,8 @@ export interface PriceRule {
     currency: string;
     validFrom?: number;
     validTo?: number;
-    /**
-     * The contract that placed this rule. Declared now because it is the top rung of the ladder: a
-     * contract price is not a second pricing mechanism, it is a price rule with an owner and a term.
-     */
-    contractId?: string;
-    /** The administration this rule belongs to. Unset = the default one. */
-    businessEntityId?: string;
+    /** The administration this rule belongs to. */
+    businessEntityId: string;
     createdBy: string;
     createdAt?: number;
 }
@@ -228,7 +239,7 @@ export interface RateCard {
     currency: string;
     validFrom?: number;
     validTo?: number;
-    businessEntityId?: string;
+    businessEntityId: string;
     archived?: boolean;
     createdBy: string;
     createdAt?: number;

package/dist/entities/company/role.d.ts

@@ -1,3 +1,4 @@
+import { PostalAddress } from '../organization/types';
 /** Which side of the table a company sits on, for one administration. */
 export type CompanyRoleKind = "customer" | "supplier";
 export declare const COMPANY_ROLE_KINDS: readonly CompanyRoleKind[];
@@ -31,3 +32,16 @@ export interface EnsureCompanyRoleRequest {
 }
 /** The payment-term direction a role pays in: a customer pays us, we pay a supplier. */
 export declare const roleDirection: (role: CompanyRoleKind) => "sales" | "purchase";
+/**
+ * A party as a document went out to it (review R2): frozen at issue, so the books, the EC sales
+ * list and the audit file show who it was then, never crm today. `number` is its role number at
+ * the issuing administration (the debtor number).
+ */
+export interface PartySnapshot {
+    companyId: string;
+    number?: string;
+    name: string;
+    vatNumber?: string;
+    kvkNumber?: string;
+    address?: PostalAddress;
+}