@opencxh/domain 1.302.0 → 1.303.0

package/dist/entities/money/tax.d.ts

@@ -30,6 +30,8 @@ export interface TaxRate {
  * line from this, and the bookkeeping connector maps it onto its own tax code.
  */
 export type TaxRateKind = "standard" | "reduced" | "zero" | "reverse_charge" | "exempt";
+/** The rate a line falls back to when neither the article nor the caller names one. */
+export declare const DEFAULT_TAX_RATE_KEY = "high";
 /** The Dutch defaults an organisation starts with. It may edit them; it may not compute them. */
 export declare const NL_TAX_RATES: readonly TaxRate[];
 /**
@@ -67,11 +69,15 @@ export interface TaxCode {
     selfAssessed?: boolean;
     /** Counts in the EC sales list (ICP). */
     icp?: boolean;
+    /** Which column of the EC sales list: absent on an ICP code = services. */
+    icpKind?: IcpKind;
     /** Deductible share of input VAT, mixed use. Absent = 100. */
     deductiblePercent?: number;
     archived?: boolean;
     order?: number;
 }
+/** The EC sales list reports goods, services and triangular (ABC) supplies apart. */
+export type IcpKind = "goods" | "services" | "triangular";
 export interface TaxCodeRate {
     /** `"2019-01-01"`. Days, compared as strings. */
     validFrom: string;

package/dist/entities/money/totals.d.ts

@@ -1,4 +1,4 @@
-import { TransactionLine, TransactionTotals } from '../transaction/types';
+import { SalesLine, TransactionTotals } from '../transaction/types';
 import { Cents } from './money';
 import { TaxRate } from './tax';
 /**
@@ -19,10 +19,10 @@ import { TaxRate } from './tax';
  * of the line total — `priceOver`, so the line total is rounded once and then split by calendar.
  * Without a service period (a quote) it is one period's amount.
  */
-export declare function lineNet(line: Pick<TransactionLine, "kind" | "quantity" | "unitPriceCents" | "discountPercent" | "pricePer" | "servicePeriod">): Cents;
+export declare function lineNet(line: Pick<SalesLine, "kind" | "quantity" | "unitPriceCents" | "discountPercent" | "pricePer" | "servicePeriod">): Cents;
 export interface PricedTransaction {
     /** The same lines with `netCents` and `taxCents` filled in. */
-    lines: TransactionLine[];
+    lines: SalesLine[];
     totals: TransactionTotals;
 }
 /**
@@ -36,6 +36,6 @@ export interface PricedTransaction {
  * rate, because that is a property of the sale and not of the product.
  *
  * An **optional** line is priced like any other and then left out of every sum — see
- * `TransactionLine.optional`.
+ * `SalesLine.optional`.
  */
-export declare function transactionTotals(lines: readonly TransactionLine[], rates: readonly TaxRate[], overrideKey?: string): PricedTransaction;
+export declare function transactionTotals(lines: readonly SalesLine[], rates: readonly TaxRate[], overrideKey?: string): PricedTransaction;

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

@@ -0,0 +1,57 @@
+import { DeliverTo, SupplierOffer } from './types';
+/** A hand-set stand ("called, they have 5") counts for a day (plan 045 B.6). */
+export declare const MANUAL_STOCK_FRESH_MS: number;
+/** What one need asks of a source. */
+export interface OfferNeed {
+    /** Base units. */
+    quantity: number;
+    /** The sale's commitment (`Commitment.termMonths`); absent = cancel any time. */
+    termMonths?: number;
+    /** `own` through our warehouse, anything else straight to the customer. */
+    deliverTo?: DeliverTo["kind"];
+    /** The delivery check the sale was made on: only what it found available qualifies (6c). */
+    qualified?: readonly {
+        app: string;
+        offer: string;
+    }[];
+    /** The administration's currency; prices in another one need `rates`. */
+    currency: string;
+    /** Units of `currency` per one unit of the key (ECB, of the day). */
+    rates?: Readonly<Record<string, number>>;
+    /** A person's pick: it stands, even when it no longer fits — the reason still shows. */
+    pinned?: string;
+}
+/** Known enough, unknown (no feed, stale, or a count the supplier does not give), known short. */
+export type OfferStock = "enough" | "unknown" | "short";
+export type Unsuitable = "invalid" | "term" | "dropship" | "qualification";
+export interface RankedOffer<T extends SupplierOffer = SupplierOffer> {
+    offer: T;
+    stock: OfferStock;
+    /** What the supplier said, when fresh. */
+    qty?: number;
+    /** Per product unit over a year, in the administration's currency; `null` = no price to compare. */
+    unitCents: number | null;
+    leadDays?: number;
+    unsuitable?: Unsuitable;
+}
+/**
+ * Why the chosen one: the preferred offer (`preferred`), the preferred one was short
+ * (`preferred_short`, chosen is the next best), only one qualified (`only`), the best of equals
+ * (`best`), nobody has enough (`short`: chosen has the most, the rest is a person's split), or a
+ * person picked it (`picked`).
+ */
+export type ChoiceWhy = "preferred" | "preferred_short" | "only" | "best" | "short" | "picked";
+export interface OfferChoice<T extends SupplierOffer = SupplierOffer> {
+    chosen: RankedOffer<T> | null;
+    why?: ChoiceWhy;
+    /** Every other offer, best first; the unsuitable last with their reason. */
+    alternatives: RankedOffer<T>[];
+    /** What `unitCents` is in: the administration's currency. */
+    currency: string;
+}
+/**
+ * The best source for one need (plan 045 B.2): suitability first, then stock, then price. Policy
+ * (Vincent 03-10): the preferred offer (`isDefault`) wins unless it is known short; the cheaper one
+ * is a hint in the alternatives. Nobody enough: the one with the most, never a split.
+ */
+export declare function chooseOffer<T extends SupplierOffer>(offers: readonly T[], need: OfferNeed, now: number): OfferChoice<T>;

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

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

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

@@ -1,5 +1,5 @@
 import { Period } from '../agreement/period';
-import { Agreement, AgreementLine } from '../agreement/types';
+import { Agreement, AgreementLine, LinePrice } from '../agreement/types';
 import { Cents } from '../money/money';
 /** A sales line, followed through its changes: the agreement and the series it belongs to. */
 export interface SalesLineRef {
@@ -7,24 +7,28 @@ export interface SalesLineRef {
     seriesId: string;
 }
 /**
- * A subscription at a supplier: the shape of a sales agreement line, plus where it came from and
- * whom it is for. Its `price` is the snapshot taken when it was made — an offer that gets dearer
- * later changes nothing here; a new price is a successor line from a date.
+ * A subscription at a supplier, one row in `purchase_contract_line` (review R5): its `price` is the
+ * snapshot taken when it was made — an offer that gets dearer later changes nothing here; a new
+ * price is a successor row in the same series from a date. What was invoiced is `purchase_match`.
  */
-export interface PurchaseAgreementLine extends AgreementLine {
+export interface SupplierContractLine extends Pick<AgreementLine, "id" | "productId" | "name" | "unitKey" | "factor" | "commitment" | "quantity" | "endsAt"> {
+    /** The supplier's price, a snapshot taken when the row was made. */
+    price?: LinePrice;
+    contractId: string;
+    /** One subscription through its changes; the first row's own id. */
+    seriesId: string;
+    startsAt: number;
     /** Provenance only: the offer it was bought on. The price is `price`, not the offer's. */
     offerId?: string;
-    /** Their subscription id (Pax8, Microsoft). */
+    /** Their subscription id (Pax8, Microsoft): what a supplier invoice line is matched on. */
     externalRef?: string;
-    /** What the supplier handed back when it was made (a tenant id, an account id). */
-    fulfillment?: Record<string, string>;
-    /** Where it landed when that is not the supplier, so an end takes it off there first. */
-    deliveredTo?: {
-        app: string;
-        externalRef?: string;
-    };
+    /**
+     * The fulfilment item this pays for (047 step 6): its sale, what it runs on and what the supplier
+     * handed back live there. A line without one is purchase's own (rent, a contract by hand).
+     */
+    itemId?: string;
     customerCompanyId?: string;
-    /** The sales line that passes this on, followed by series. */
+    /** A line by hand: the sales line that passes it on. A line with `itemId` reads the item's. */
     salesLine?: SalesLineRef;
     /**
      * `variable`: no price, the invoice decides the amount (transit minutes). Nothing is expected;
@@ -34,18 +38,24 @@ export interface PurchaseAgreementLine extends AgreementLine {
     expected?: "variable";
     /** Days from each term's start in which the supplier still takes a change (NCE: 7). */
     changeWindowDays?: number;
-    /** The order line it came from, so a second receipt updates instead of adding. */
+    /** `lineKey` of the order line it came from; a successor shares it, so it is not unique. */
     sourceKey?: string;
-    /** What supplier invoices said per period (fase 7): the history a variable line is judged on. */
-    invoiced?: {
-        from: number;
-        cents: Cents;
-    }[];
 }
-/** A supplier contract: `companyId` is the supplier; one contract holds many subscriptions. */
-export interface PurchaseAgreement extends Omit<Agreement, "lines"> {
-    lines: PurchaseAgreementLine[];
+/**
+ * A supplier contract's header, one per supplier × administration (044): no sales fields, no
+ * lines — those are rows of their own. `companyId` is the supplier.
+ */
+export interface SupplierContract extends Pick<Agreement, "id" | "organizationId" | "businessEntityId" | "title" | "companyId" | "currency" | "status" | "startsAt" | "endsAt" | "commitment" | "createdBy" | "createdAt" | "updatedAt"> {
 }
+/** A header with its rows, read together for a computation over the whole contract. */
+export type SupplierContractWithLines = SupplierContract & {
+    lines: readonly SupplierContractLine[];
+};
+/** What supplier invoices said per period, per line id: derived from `purchase_match`. */
+export type InvoicedHistory = ReadonlyMap<string, readonly {
+    from: number;
+    cents: Cents;
+}[]>;
 export interface ExpectedLine {
     lineId: string;
     kind: "fixed" | "count" | "variable";
@@ -57,7 +67,9 @@ export interface ExpectedLine {
  * the days it ran (the same `lineNet` the sales run bills with), or "count" / "variable" where the
  * amount is not ours to know in advance.
  */
-export declare function expectedFor(agreement: Pick<PurchaseAgreement, "startsAt" | "endsAt" | "lines">, window: Period): ExpectedLine[];
+export declare function expectedFor(agreement: Pick<SupplierContract, "startsAt" | "endsAt"> & {
+    lines: readonly SupplierContractLine[];
+}, window: Period): ExpectedLine[];
 /**
  * A variable amount that moved more than `threshold` against the average of the (up to) three
  * periods before: that is work for a person, not a number to wave through.
@@ -73,6 +85,11 @@ export interface SalesLineState extends SalesLineRef {
     unbilled: Period[];
     /** The sales line has ended or its agreement is not active. */
     ended?: boolean;
+    /** The last period invoiced and how many it billed: "gefactureerd" on Producten bij klanten. */
+    billed?: {
+        quantity: number;
+        period: Period;
+    };
 }
 export type ContractSignal = {
     kind: "not_covered";
@@ -111,6 +128,8 @@ export interface SignalOptions {
     noticeDays?: number;
     /** A change window closing this soon is a reminder. */
     windowDays?: number;
+    /** What was invoiced per line, for the variable jump. */
+    invoiced?: InvoicedHistory;
 }
 /**
  * Everything about a supplier contract a person should look at, apart:
@@ -121,4 +140,4 @@ export interface SignalOptions {
  * - **notice due / change window**: reminders before the dates that decide the next term;
  * - **variable jump**: a variable amount moved more than 30%.
  */
-export declare function contractSignals(contracts: readonly PurchaseAgreement[], sales: readonly SalesLineState[], now: number, options?: SignalOptions): ContractSignal[];
+export declare function contractSignals(contracts: readonly SupplierContractWithLines[], sales: readonly SalesLineState[], now: number, options?: SignalOptions): ContractSignal[];

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

@@ -1,7 +1,5 @@
-import { ProvisionableOffer, ProvisioningAction } from '../../platform/provisioning';
-import { Agreement } from '../agreement/types';
-import { PurchaseAgreement } from './contract';
-import { SupplierOffer } from './types';
+import { ProvisioningAction } from '../../platform/provisioning';
+import { Agreement, AgreementLine } from '../agreement/types';
 /** One thing to order, change or end, as "Te bestellen" lists it. */
 export interface DemandItem {
     /** Stable: the sales series, or the customer's account at the supplier. */
@@ -18,14 +16,6 @@ export interface DemandItem {
     targetQuantity?: number;
     from?: number;
     customerCompanyId: string;
-    salesLine?: {
-        agreementId: string;
-        seriesId: string;
-    };
-    contractLine?: {
-        contractId: string;
-        lineId: string;
-    };
     /** Epoch ms it takes effect: the term's end for an end or a reduction outside the window. */
     effectiveAt?: number;
     /** The last day to send it for `effectiveAt`; past it, `effectiveAt` is the next term's end. */
@@ -36,33 +26,25 @@ export interface DemandItem {
     nextTerm?: boolean;
     /** The purchase runs on after the sale ends: we pay until then. */
     runsOnUntil?: number;
-    /** The account item this waits for. */
-    waitsFor?: string;
-    /** It lands on another platform than the supplier's (a Telnyx number on Eylo). */
-    deliverTo?: {
-        app: string;
-        offer: string;
+    /**
+     * An end at a provider that prices it (045 D N-2): what ending costs, shown before "Maak
+     * concept" and put on the order as it was shown. `costUnknown`: the provider gave no answer.
+     */
+    cost?: {
+        parts: {
+            label: string;
+            cents: number;
+            recurring?: "month";
+        }[];
+        warnings?: string[];
     };
+    costUnknown?: boolean;
+    /** The request's answers (the site as a crm address id): what a per-order price is asked on. */
+    params?: Record<string, string>;
+    /** The request this waits for: the customer's account before its numbers. */
+    waitsFor?: string;
 }
-export interface DemandInput {
-    agreements: readonly Agreement[];
-    contracts: readonly PurchaseAgreement[];
-    offers: readonly SupplierOffer[];
-    /** Provider describes, by `app:offer`. */
-    provisionable: ReadonlyMap<string, ProvisionableOffer>;
-    /** Keys already on an order that has not settled: never proposed twice. */
-    open: ReadonlySet<string>;
-    now: number;
-}
-/**
- * What to order, change or end so purchase follows sales (fase 9). Per sales series with a fixed
- * count and a default offer:
- * - no contract line passes it on: buy the count;
- * - the contract has fewer: one change to the new count;
- * - the contract has more: lower it now inside the supplier's change window, else do not renew
- *   the difference at the term's end;
- * - the sale has an end: end the purchase at the first term end the notice still reaches, with
- *   the deadline to send it by, and a signal when we pay on after the customer stopped.
- * An item that needs the customer's account at the supplier gets that account first.
- */
-export declare function demandFor(input: DemandInput): DemandItem[];
+export declare const seriesOf: (line: AgreementLine) => string;
+/** The line of a series that runs on `at`, else the one that starts next, else its last. */
+export declare function currentOf<T extends AgreementLine>(parent: Pick<Agreement, "startsAt" | "endsAt">, lines: readonly T[], at: number): T;
+export declare function bySeries<T extends AgreementLine>(lines: readonly T[]): Map<string, T[]>;

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

@@ -6,11 +6,12 @@ import { OfferAvailability, SupplierOffer } from './types';
  * turned into a product or an offer by itself.
  */
 /** The columns a feed can fill. `vendorSku` or `gtin` is the key; the rest is optional. */
-export type FeedColumn = "vendorSku" | "gtin" | "description" | "brand" | "group" | "cost" | "list" | "currency" | "stock" | "leadDays";
+export type FeedColumn = "vendorSku" | "gtin" | "description" | "brand" | "group" | "cost" | "list" | "currency" | "stock" | "leadDays" | "lotSize" | "dropship";
 export declare const FEED_COLUMNS: readonly FeedColumn[];
 /** Per column, the header it is read from. Set once (the AI proposes, a person approves). */
 export type FeedMapping = Partial<Record<FeedColumn, string>>;
-export type FeedSource = "upload" | "mail" | "storage";
+/** `api`: the assortment from a provisioning app (plan 045 D N-1) instead of a file. */
+export type FeedSource = "upload" | "mail" | "storage" | "api";
 /** How often a new file is expected; it decides how long a stock figure counts as fresh. */
 export type FeedEvery = "day" | "week" | "month";
 export declare const FEED_EVERY_MS: Record<FeedEvery, number>;
@@ -23,6 +24,11 @@ export interface SupplierFeed {
     supplierCompanyId: string;
     name?: string;
     source: FeedSource;
+    /** For `api`: the app that lists its assortment, and which of its connections. */
+    api?: {
+        app: string;
+        accountId: string;
+    };
     /** For `storage`: the folder it reads the newest csv from (a dated file each time is fine). */
     storage?: {
         mountId: string;
@@ -61,6 +67,10 @@ export interface FeedRow {
     /** `null`: the file says nothing about stock, or "on request". */
     stock?: number | null;
     leadDays?: number;
+    lotSize?: number;
+    dropship?: SupplierOffer["dropship"];
+    /** From an `api` feed: the provider's offer key a new offer is ordered through. */
+    offer?: string;
 }
 export interface FeedReadResult {
     rows: FeedRow[];
@@ -96,8 +106,9 @@ export type FeedMatch = {
 export declare function matchFeed(rows: readonly FeedRow[], offers: readonly SupplierOffer[], products: readonly FeedProduct[]): FeedMatch[];
 export interface OfferChange {
     offerId: string;
-    set: Partial<Pick<SupplierOffer, "costCents" | "listCents" | "currency" | "vendorSku">> & {
-        availability: OfferAvailability;
+    set: Partial<Pick<SupplierOffer, "costCents" | "listCents" | "currency" | "vendorSku" | "lotSize" | "dropship" | "validTo">> & {
+        /** Absent only when an `api` feed no longer lists it: then it ends (`validTo`). */
+        availability?: OfferAvailability;
     };
     /** A price moved more than the feed's threshold; applied, and said. */
     jump?: {
@@ -116,6 +127,8 @@ export interface FeedUnmatched {
     costCents?: Cents;
     /** An article we have, with no offer from this supplier yet: "make an offer" is one click. */
     productId?: string;
+    /** From an `api` feed: the provider's offer key (045 D N-1). */
+    offer?: string;
 }
 export interface FeedOutcome {
     changes: OfferChange[];
@@ -129,7 +142,7 @@ export interface FeedOutcome {
  * What the run writes. Every matched offer gets a fresh stock stamp — the freshness is the
  * point of a feed; price, advice price and currency only when the file has them.
  */
-export declare function feedOutcome(matches: readonly FeedMatch[], offers: readonly SupplierOffer[], now: number, jumpPercent?: number): FeedOutcome;
+export declare function feedOutcome(matches: readonly FeedMatch[], offers: readonly SupplierOffer[], now: number, jumpPercent?: number, every?: FeedEvery): FeedOutcome;
 /**
  * A first mapping from the header alone: every exact word first, then a header that starts with
  * one — so "Productgroep" is the group before "product" claims it as the description.
@@ -168,3 +181,38 @@ export interface FeedImportStatus {
     startedAt: number;
     finishedAt?: number;
 }
+/** A run as a screen reads it: the work left is a count, not the list of writes. */
+export interface FeedRunView {
+    id: string;
+    organizationId: string;
+    feedId: string;
+    state: "applying" | "done" | "failed";
+    /** Why it failed: `feed_no_key`, `feed_missing_headers`. */
+    reason?: string;
+    missingHeaders?: string[];
+    rows: number;
+    errors: {
+        line: number;
+        message: string;
+    }[];
+    /** Offers updated; `unchanged` of them only had their freshness renewed. */
+    updated: number;
+    unchanged: number;
+    gone: number;
+    jumps: {
+        offerId: string;
+        fromCents: number;
+        toCents: number;
+        percent: number;
+    }[];
+    unmatched: FeedUnmatched[];
+    /** More lines than `unmatched` holds. */
+    unmatchedTotal: number;
+    applied: number;
+    pendingCount: number;
+    importJob?: FeedImportStatus;
+    startedAt: number;
+    finishedAt?: number;
+    createdBy: string;
+    createdAt?: number;
+}

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

@@ -1,3 +1,4 @@
+export * from './choose';
 export * from './contract';
 export * from './demand';
 export * from './feed';

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

@@ -1,8 +1,9 @@
 import { TransactionKind } from '../transaction/kinds';
+import { PurchaseStatus } from './types';
 /**
  * What `apps/purchase` issues: the same engine as a quote, its own table. `sent` is issued (a
  * number and the paper); the supplier confirms, and the goods coming in make it `received`.
  * Walking back one step stays allowed — a return reopens a received order.
  */
-export declare const PURCHASE_KINDS: readonly TransactionKind[];
+export declare const PURCHASE_KINDS: readonly TransactionKind<PurchaseStatus>[];
 export declare const PURCHASE_ORDER_KIND = "purchase_order";

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

@@ -1,21 +1,39 @@
+import { ProductTracking } from '../catalog/types';
 import { PricePer } from '../money/period-price';
-import { GoodsReceipt, GoodsReceiptLine, PurchaseLine, SupplierOffer } from './types';
+import { GoodsReceipt, GoodsReceiptLine, InvoiceState, PurchaseLine, SupplierOffer } from './types';
 /** What came in for one order line: booked receipts in, returns out. */
 export declare function receivedFor(poLineId: string, receipts: readonly GoodsReceipt[]): number;
 export type ReceiptState = "none" | "partial" | "full";
 /** Over the product lines of an order. */
-export declare function receiptState(lines: readonly Pick<PurchaseLine, "kind" | "quantity" | "receivedQty">[]): "none" | "partial" | "full";
+export declare function receiptState(lines: readonly Pick<PurchaseLine, "kind" | "quantity" | "receivedQty">[]): "none" | "full" | "partial";
+type Billable = Pick<PurchaseLine, "kind" | "quantity" | "billedQty" | "act" | "unitPriceCents">;
+/** A supplier invoice is expected for this line: a buy, or a change that costs something. */
+export declare const expectsInvoice: (line: Billable) => boolean;
+/** `full` when every line that expects an invoice is billed; derived by whoever writes the lines. */
+export declare function invoiceState(lines: readonly Billable[]): InvoiceState;
 export interface GoodsReceiptProblem {
-    code: "receipt_over_ordered" | "receipt_return_over_received" | "receipt_serials_count";
+    code: "receipt_over_ordered" | "receipt_return_over_received" | "receipt_serials_count" | "receipt_serials_required" | "receipt_batches_count" | "receipt_batches_required";
     poLineId: string;
 }
 /**
  * Why a receipt cannot be booked: more in than still open, more back than came in, or serial
- * numbers that do not match the count in base units. No serials is fine (bulk goods); some serials
- * must be all.
+ * numbers that do not match the count in base units. No serials is fine for bulk goods; some
+ * serials must be all. A serial article (046 `tracking`) comes in with every serial: without them
+ * a drop shipment can never be delivered (Exact v2 nr. 8). A batch article likewise with batches
+ * that add up, in base units.
+ */
+export declare function goodsReceiptProblems(receipt: Pick<GoodsReceipt, "movement" | "lines">, poLines: readonly Pick<PurchaseLine, "id" | "quantity" | "factor" | "productId">[], booked: readonly GoodsReceipt[], tracking?: ReadonlyMap<string, ProductTracking>): GoodsReceiptProblem[];
+/** `<productId>#<serial>` for every serial on these lines: a serial is unique per article. */
+export declare function serialKeysOf(lines: readonly Pick<GoodsReceiptLine, "poLineId" | "serials">[], poLines: readonly Pick<PurchaseLine, "id" | "productId">[]): string[];
+/**
+ * Which of `keys` are in house already: booked in more often than sent back, over every receipt
+ * (any order). A serial that went back may come in again: a swap after a repair.
+ */
+export declare function serialsInHouse(keys: readonly string[], receipts: readonly Pick<GoodsReceipt, "movement" | "status" | "serialKeys">[]): string[];
+/**
+ * Lines of a receipt worth keeping: a positive quantity, serials trimmed and unique, batches with
+ * a code and a positive quantity (base units).
  */
-export declare function goodsReceiptProblems(receipt: Pick<GoodsReceipt, "movement" | "lines">, poLines: readonly Pick<PurchaseLine, "id" | "quantity" | "factor">[], booked: readonly GoodsReceipt[]): GoodsReceiptProblem[];
-/** Lines of a receipt worth keeping: a positive quantity, serials trimmed and unique. */
 export declare function cleanReceiptLines(lines: readonly GoodsReceiptLine[]): GoodsReceiptLine[];
 /** Valid on `at`. */
 export declare function offerValid(offer: Pick<SupplierOffer, "validFrom" | "validTo">, at: number): boolean;
@@ -28,6 +46,12 @@ export declare function defaultOffer<T extends SupplierOffer>(offers: readonly T
 export declare function toProductUnits(source: {
     factor?: number;
 }, qty: number): number;
+/**
+ * Base units to purchase units: a box of 10 for 12 pieces is 2 boxes. Raised to the offer's
+ * `minQty` (Exact v2 §5), then to a multiple of its `lotSize`; what is bought beyond the need goes
+ * to stock.
+ */
+export declare function purchaseUnits(base: number, factor: number | undefined, offer?: Pick<SupplierOffer, "minQty" | "lotSize">): number;
 /**
  * The offer's cost per product unit, as amount, currency and period — what is written back to the
  * product. Never a monthly equivalent: € 222 per year stays € 222 per year.
@@ -39,3 +63,4 @@ export declare function productCost(offer: SupplierOffer): {
 };
 /** Offers side by side: each over one year, per product unit. A one-off stays itself. */
 export declare function costOverYear(offer: SupplierOffer): number;
+export {};

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