@opencxh/domain 1.294.0 → 1.295.1

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

@@ -0,0 +1,18 @@
+import { Transaction, TransactionLine } 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;
+/**
+ * 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).
+ *
+ * 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.
+ */
+export declare function agreementFromQuote(quote: Transaction, 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;

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

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

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

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

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

@@ -0,0 +1,44 @@
+import { Agreement, AgreementLine, AgreementStatus, Commitment } from './types';
+/**
+ * Where an agreement may go. `draft → active` is starting it; `active → ended` is not a click but
+ * the run, once the last window and its grace are billed (see {@link finishedAt}) — a person ends
+ * an agreement by giving it an end date. `ended → active` is a new term: no catch-up billing.
+ */
+export declare const AGREEMENT_TRANSITIONS: Record<AgreementStatus, readonly AgreementStatus[]>;
+export declare function canMoveAgreement(from: AgreementStatus, to: AgreementStatus): boolean;
+/**
+ * The last moment anything is still due on an agreement with an end: the close of each line's
+ * last window plus grace, so usage in arrears and a prorated settlement still ride along.
+ * `null` while any line runs open-ended.
+ */
+export declare function finishedAt(agreement: Pick<Agreement, "startsAt" | "endsAt" | "interval" | "graceDays" | "lines">): number | null;
+/**
+ * Where a series' commitment counts from: its first line. A change (10 → 12 seats) is a successor
+ * line, but the term is the subscription's — seats added under NCE end with the rest.
+ */
+export declare function seriesStart(parent: Pick<Agreement, "startsAt" | "endsAt">, series: readonly Pick<AgreementLine, "startsAt" | "endsAt">[]): number;
+/** The end (exclusive) of the commitment term that contains `at`, counted from `start`. */
+export declare function termEndAt(start: number, commitment: Commitment, at: number): number;
+/** The start of the commitment term that contains `at`: where a change window opens. */
+export declare function termStartAt(start: number, commitment: Commitment, at: number): number;
+/**
+ * The last day to give notice so the line stops at the end of the term running on `now`; past it,
+ * the deadline of the next term. `null` without a commitment (cancel any time) or when a
+ * non-renewing term simply runs out.
+ */
+export declare function noticeDeadline(start: number, commitment: Commitment | undefined, now: number): number | null;
+/**
+ * When the line really ends if notice is given on `noticeAt`: the end of the running term when
+ * the notice is in time, else the end of the next one. Without a commitment, at once.
+ * 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;
+/** 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. */
+export declare function changesBilledLine(before: AgreementLine, after: AgreementLine): boolean;
+/**
+ * A change from `at`: the line ends there and a successor in the same series takes over with the
+ * changed fields, up to the old end. What was billed keeps saying what it said.
+ */
+export declare function splitLine(line: AgreementLine, at: number, changed: Partial<AgreementLine>, successorId: string): [AgreementLine, AgreementLine];

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

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

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

@@ -1,4 +1,5 @@
 import { Cents } from '../money/money';
+import { PricePer } from '../money/period-price';
 import { Period } from './period';
 import { Agreement, AgreementLine, LineBilling, LineRhythm } from './types';
 /** A fixed line keeps its own rhythm; usage follows the agreement, it is read per period. */
@@ -11,6 +12,7 @@ export interface BilledLine {
     servicePeriod: Period;
     quantity: number;
     unitPriceCents: Cents;
+    pricePer?: PricePer;
     correction?: boolean;
 }
 /** One window of one line that is due and not yet on an invoice. */
@@ -32,6 +34,8 @@ export interface Correction {
     part: Period;
     quantity: number;
     unitPriceCents: Cents;
+    /** From the billed line: a period price settles by calendar share, never at today's price. */
+    pricePer?: PricePer;
 }
 /**
  * What an agreement owes on `now`, per line: every window that is due minus the windows an

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

@@ -1,5 +1,6 @@
 import { PriceBand } from '../catalog/rating';
 import { Cents } from '../money/money';
+import { PricePer } from '../money/period-price';
 /**
  * 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).
@@ -32,6 +33,12 @@ export interface Agreement {
      */
     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. */
+    commitment?: Commitment;
+    /** The quote it was made from, if any. */
+    sourceTransactionId?: string;
     /**
      * The account usage is read from (a PBX tenant). Usage lines without an account of their own
      * take this one; a line may still name another, say texts from a second source.
@@ -42,13 +49,42 @@ export interface Agreement {
     createdAt?: number;
     updatedAt?: number;
 }
+/** Moves only along `AGREEMENT_TRANSITIONS`; `ended` is set by the run once nothing is left. */
 export type AgreementStatus = "draft" | "active" | "ended";
+/**
+ * What a customer (or we, at a supplier) committed to: a first term, notice before its end, and
+ * what happens after — `term` renews for the same length, `month` runs on month by month (the
+ * Dutch default after a minimum term), `none` stops at the end of the first term.
+ */
+export interface Commitment {
+    termMonths: number;
+    noticeDays: number;
+    renew: "term" | "month" | "none";
+}
+/** A price fixed on the line when it was agreed, instead of the ladder at billing time. */
+export interface LinePrice {
+    cents: Cents;
+    currency: string;
+    per?: PricePer;
+    /** The unit the price is for, when it is not the product's (a supplier's box of 10). */
+    unit?: string;
+}
 export type AgreementInterval = "month" | "quarter" | "year";
 export interface AgreementLine {
     id: string;
     productId: string;
     /** Copied from the product, like a transaction line: the agreement must stay readable. */
     name: string;
+    /**
+     * One line through its changes: 10 seats ending on 12 May and 12 seats from then share it. A
+     * billed line never changes; a change ends it and starts a successor in the same series.
+     * 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.
@@ -128,6 +164,8 @@ export interface RunLine {
     taxRateKey: string;
     quantity: number;
     unitPriceCents: Cents;
+    /** The period the unit price is for; the line then bills its share of `servicePeriod`. */
+    pricePer?: PricePer;
     priceSourceKey: string;
     /** What it covers: the part of the line's window it ran. */
     servicePeriod: {

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

@@ -46,7 +46,7 @@ export declare function reconciliationBalances(rec: Pick<Reconciliation, "alloca
  * the item (an invoice +, a receipt −). What sales hears, and what the books show.
  */
 export declare function paymentOfItem(grossCents: Cents, openCents: Cents): {
-    state: "paid" | "overpaid" | "unpaid" | "partially_paid";
+    state: "unpaid" | "partially_paid" | "paid" | "overpaid";
     paidCents: number;
     openCents: number;
 };

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

@@ -1,6 +1,7 @@
 import { BookingDocument } from '../../platform/bookkeeping';
 import { Cents } from '../money/money';
 import { TaxRateKind } from '../money/tax';
+import { MatchAllocation, MatchVerdict } from '../purchase/match';
 import { WorkQueueItem } from './types';
 /**
  * A receipt or purchase invoice, as finance holds it until it is booked (plan 039 datamodel §6.4).
@@ -25,6 +26,20 @@ export interface Receipt {
     };
     receivedVia: "mail" | "upload";
     receivedAt: number;
+    /** A supplier's credit note carries negative amounts and names the invoice it credits. */
+    kind?: "invoice" | "credit_note";
+    creditsReceiptId?: string;
+    /**
+     * The order and contract match purchase proposed (fase 7): what each line pays for, and whether
+     * it all is what was ordered or agreed. `ok` approves it without a person.
+     */
+    match?: ReceiptMatch;
+    /** From the bank reconciliation, whole state: what is still to pay. */
+    payment?: {
+        state: "unpaid" | "partially_paid" | "paid" | "overpaid";
+        openCents: Cents;
+        lastPaymentAt?: number;
+    };
     mail?: {
         interactionId: string;
         activityId: string;
@@ -33,6 +48,11 @@ export interface Receipt {
     };
     supplierCompanyId?: string;
     fields: ReceiptFields;
+    /**
+     * Every line as printed, never merged: a Pax8 invoice with twelve subscriptions keeps twelve.
+     * The one truth — booking lines are grouped from these when it is booked, and an order match
+     * reads them per subscription and period.
+     */
     lines: ReceiptLine[];
     totals: {
         netCents: Cents;
@@ -74,9 +94,36 @@ export interface ReceiptFields {
     issueDate?: Field<string>;
     dueDate?: Field<string>;
     currency?: Field<string>;
+    /**
+     * Euro per unit of `currency`, a decimal string: the ECB rate on the invoice date as a proposal
+     * (`ai` then means "proposed"), a person may overwrite it. Absent for a document in euro.
+     */
+    fxRate?: Field<string>;
 }
+export interface ReceiptMatch {
+    allocations: MatchAllocation[];
+    unmatched: 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 {
+    /** Stable for the line's life; what a treatment or a match points at (`receipt:<id>#<lineId>`). */
+    id?: string;
     description?: string;
+    quantity?: number;
+    unitPriceCents?: Cents;
+    /** Their article or product code. */
+    sku?: string;
+    /** Their subscription or order id on the line (Pax8 `subscriptionId`). */
+    externalRef?: string;
+    /** The service period it bills, `YYYY-MM-DD` both, `to` inclusive as printed. */
+    period?: {
+        from: string;
+        to: string;
+    };
     netCents: Cents;
     taxCents: Cents;
     /** `TaxCode.key`, e.g. `high`. */
@@ -88,6 +135,15 @@ export interface ReceiptLine {
     aiSuggested?: boolean;
     /** Absent = a cost. Own books only: the line becomes a fixed asset or is spread over months. */
     treatment?: ReceiptLineTreatment;
+    /**
+     * Sold on (`resale`, the M365 seats for Acme) or ours. Resale is cost of sales for that
+     * 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;
 }
 /**
  * What a line becomes besides its booking (plan 041 §4): a fixed asset in a group (its account
@@ -130,6 +186,12 @@ export declare function receiptProblems(receipt: Pick<Receipt, "fields" | "lines
  * Where it sits in "Te verwerken": ready to confirm when nothing is missing, to check when only
  * the reading needs a look, to choose when an account is missing (no proposal to confirm).
  */
-export declare function receiptGroupOf(receipt: Pick<Receipt, "fields" | "lines" | "status">): WorkQueueItem["group"] | null;
+export declare function receiptGroupOf(receipt: Pick<Receipt, "fields" | "lines" | "status" | "match">): 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
+ * exactly the lines, and the lines stay what the supplier printed.
+ */
+export declare function bookingLinesOf(lines: readonly ReceiptLine[], fallback?: string): BookingDocument["lines"];
 /** The receipt as the books need it: a purchase, with the account per line a person chose. */
 export declare function bookingDocumentOfReceipt(receipt: Receipt, sourceApp?: string): BookingDocument;

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

@@ -27,6 +27,8 @@ export interface LedgerMappingRule {
         ledgerCategoryKey?: string;
         taxRateKey?: string;
     };
+    /** Sales or purchases. Absent = sales: every rule made before purchases could be mapped. */
+    direction?: "sale" | "purchase";
     /** `BookkeepingDescribe.ledgerOptions[].key`. */
     targetKey: string;
     externalTaxCode?: string;

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

@@ -1,4 +1,5 @@
 import { Cents } from '../money/money';
+import { PricePer } from '../money/period-price';
 import { TransactionLine } from '../transaction/types';
 import { PriceRule, Product } from './types';
 /**
@@ -27,8 +28,12 @@ export interface PriceContext {
     /** Epoch ms; the validity window is judged against this, not against "now". */
     at: number;
 }
+/** Amount, currency and period travel together: € 222 means nothing without "per year". */
 export interface ResolvedPrice {
     unitPriceCents: Cents;
+    currency: string;
+    /** Absent = once, or per unit. */
+    per?: PricePer;
     /** Where this amount came from. Almost free, and the only question a salesperson asks. */
     sourceKey: string;
     ruleId?: string;

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

@@ -1,4 +1,5 @@
 import { Cents } from '../money/money';
+import { PricePer } from '../money/period-price';
 /**
  * What we sell, variants included.
  *
@@ -57,6 +58,11 @@ export interface Product {
     taxRateKey: string;
     listPriceCents: Cents;
     currency: string;
+    /**
+     * The period the list and cost price are for: € 222 per year. Absent = once, or per unit.
+     * A recurring agreement line needs one; the run bills its share of each window.
+     */
+    pricePer?: PricePer;
     /**
      * What we normally pay for this. **Not** a cost price out of an inventory valuation.
      *
@@ -65,6 +71,10 @@ export interface Product {
      * would be one typo away.
      */
     costPriceCents?: Cents;
+    /** The period the cost price is for, when it differs from {@link Product.pricePer}. */
+    costPricePer?: PricePer;
+    /** The purchase offer the cost comes from; absent = typed by hand. Read-only in the form then. */
+    costOfferId?: string;
     /** Who we buy it from. A `Company` in crm, so free — and all a later purchase order needs. */
     supplierCompanyId?: string;
     /**
@@ -75,18 +85,28 @@ export interface Product {
      * it is what was chosen.
      */
     businessEntityId?: string;
+    /** On quotes, invoices and agreements. Absent = yes; steel plate you only buy is `false`. */
+    sellable?: boolean;
+    /** On purchase orders. Absent = no. */
+    purchasable?: boolean;
     archived?: boolean;
     order?: number;
     createdBy: string;
     createdAt?: number;
     updatedAt?: number;
 }
+/** The cost price in the period of the list price, for a margin. Absent without a cost price. */
+export declare function costInPricePeriod(product: Pick<Product, "costPriceCents" | "costPricePer" | "pricePer">): Cents | undefined;
+/** Whether a sales picker offers it: absent counts as sellable, so older products stay. */
+export declare function isSellable(product: Pick<Product, "sellable" | "archived">): boolean;
+/** Whether a purchase picker offers it. */
+export declare function isPurchasable(product: Pick<Product, "purchasable" | "archived">): boolean;
 /**
  * Units follow work's `FIXED_TYPES` pattern: a fixed list plus a namespaced fallback, so an
  * unknown key reads as itself instead of breaking.
  */
 export type ProductPricing = "unit" | "rated";
-export declare const FIXED_UNITS: readonly ["piece", "hour", "day", "month", "km", "license", "minute"];
+export declare const FIXED_UNITS: readonly ["piece", "hour", "day", "month", "km", "license", "minute", "kg", "ton", "m", "m2", "m3", "liter"];
 export type FixedUnit = (typeof FIXED_UNITS)[number];
 /**
  * A price for a customer, a segment or a contract.
@@ -111,6 +131,8 @@ export interface PriceRule {
      * product ("this customer calls on Enterprise") and is ignored by the unit ladder.
      */
     unitPriceCents?: Cents;
+    /** The period a fixed price is for; absent = the product's. A discount needs none. */
+    pricePer?: PricePer;
     discountPercent?: number;
     rateCardId?: string;
     currency: string;

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

@@ -70,6 +70,12 @@ export interface Company {
     peppolId?: string;
     debtorNumber?: string;
     creditorNumber?: string;
+    /** We buy from them. Loose fields on the company, as in Exact — not a supplier entity. */
+    isSupplier?: boolean;
+    /** Their payment condition towards us; {@link Company.paymentTermCode} is ours towards them. */
+    supplierPaymentTermKey?: string;
+    /** The currency they invoice us in; empty = the administration's. */
+    supplierCurrency?: string;
     /** Raw, human-readable phone/website as entered, for display. */
     phone?: string;
     website?: string;

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

@@ -168,6 +168,14 @@ export interface AccrualTerms {
     months: number;
     resultAccountId: string;
     upfront: boolean;
+    /**
+     * The exact service period, when there is one: released by the days of each calendar month
+     * (`monthParts`), the same split the other side of the margin uses. Absent = equal months.
+     */
+    period?: {
+        from: string;
+        to: string;
+    };
 }
 export type FinancingTerms = LoanTerms | CurrentAccountTerms | ParticipationTerms | DepositTerms | FixedAssetTerms | AccrualTerms;
 export interface FinancingItem {

package/dist/entities/ledger/entry.d.ts

@@ -62,6 +62,8 @@ export interface DocumentPostingContext {
     accounts: readonly LedgerAccount[];
     rules: readonly PostingRule[];
     taxAccounts: readonly TaxAccountMapping[];
+    /** The administration's own currency; `EUR` when unset. */
+    functionalCurrency?: string;
 }
 export type DocumentEntry = {
     ok: true;
@@ -73,11 +75,15 @@ export type DocumentEntry = {
     problem: string;
 };
 /**
- * A sale or a purchase as balanced lines (plan 039 §4.6). A sale: debtors debit the gross, revenue
- * credit per line, VAT payable credit per code. A purchase the mirror, on creditors and VAT to
- * reclaim. A credit note needs nothing of its own: its amounts are already negative.
- *
- * ponytail: a reverse-charge purchase books no self-assessed VAT yet (both sides of box 4); the
- * VAT return in step 7 adds it.
+ * The lines of a sale or purchase that run over more than one calendar month: a year of M365
+ * invoiced in October is not October's revenue or cost. Own books take these through the
+ * balance and release them month by month. A journal is booked as sent.
  */
+export declare function transitoryLines(doc: BookingDocument): {
+    index: number;
+    period: {
+        from: string;
+        to: string;
+    };
+}[];
 export declare function entryLinesOf(doc: BookingDocument, context: DocumentPostingContext): DocumentEntry;

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

@@ -34,7 +34,9 @@ export interface LedgerAccount {
     createdAt?: number;
     updatedAt?: number;
 }
-export type LedgerAccountRole = "debtors" | "creditors" | "vat_payable" | "vat_receivable" | "revenue_default" | "expense_default" | "suspense" | "result";
+export type LedgerAccountRole = "debtors" | "creditors" | "vat_payable" | "vat_receivable" | "revenue_default" | "expense_default" | "suspense" | "result"
+/** Where the difference lands when a foreign document is paid at another rate than booked. */
+ | "fx_difference";
 export type JournalKind = "sales" | "purchase" | "bank" | "cash" | "memorial" | "opening";
 export interface Journal {
     id: string;

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

@@ -1,3 +1,5 @@
 export * from './money';
+export * from './month-parts';
+export * from './period-price';
 export * from './tax';
 export * from './totals';

package/dist/entities/money/month-parts.d.ts

@@ -0,0 +1,19 @@
+import { Cents } from './money';
+/**
+ * `total` over the calendar months of a period (`to` inclusive, as printed): a whole month one
+ * share, a part of one by its days, in whole cents that add up exactly — leftover cents to the
+ * first months, as `allocate` does. One distribution for revenue and cost alike, so a month's
+ * margin is the same sum on both sides. `month` is each month's first day.
+ */
+export declare function monthParts(total: Cents, period: {
+    from: string;
+    to: string;
+}): {
+    month: string;
+    cents: Cents;
+}[];
+/** How many calendar months a period touches. */
+export declare function monthsIn(period: {
+    from: string;
+    to: string;
+}): number;

package/dist/entities/money/month-parts.test.d.ts

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

package/dist/entities/money/period-price.d.ts

@@ -0,0 +1,23 @@
+import { Cents } from './money';
+/** What a recurring price is for: € 25 per month, € 222 per year. */
+export type PricePer = "month" | "quarter" | "year";
+export declare const PRICE_PERS: readonly PricePer[];
+/**
+ * `total` (one `per`, all units together) over `window`, in whole cents.
+ *
+ * The distribution key is the calendar: a yearly total is split over its 12 months with
+ * `allocate` (leftover cents to the first months), a quarterly one over its 3. A month is billed
+ * as its own share, a part of a month by its days. So month 7 on its own is exactly month 7 of a
+ * yearly run, and twelve months of € 100/year add up to € 100,00. Rounded once, at the end.
+ */
+export declare function priceOver(total: Cents, per: PricePer, window: {
+    from: number;
+    to: number;
+}): Cents;
+/**
+ * An amount per `from` restated per `to` (€ 222 per year → € 18,50 per month), for comparing two
+ * prices side by side — a margin, a cost next to a list price. **Never stored**: billing goes
+ * through {@link priceOver}, which keeps the calendar split exact.
+ */
+export declare function restate(cents: Cents, from: PricePer | undefined, to: PricePer | undefined): Cents;
+export declare function isPricePer(value: unknown): value is PricePer;

package/dist/entities/money/period-price.test.d.ts

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

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

@@ -14,8 +14,12 @@ import { TaxRate } from './tax';
  * and the tax office do.
  *
  * `quantity` may be fractional (3.5 hours); a *price* never is.
+ *
+ * A price with a period (`pricePer`) on a line with a service period bills that period's share
+ * 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: TransactionLine): Cents;
+export declare function lineNet(line: Pick<TransactionLine, "kind" | "quantity" | "unitPriceCents" | "discountPercent" | "pricePer" | "servicePeriod">): Cents;
 export interface PricedTransaction {
     /** The same lines with `netCents` and `taxCents` filled in. */
     lines: TransactionLine[];

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

@@ -0,0 +1,124 @@
+import { Period } from '../agreement/period';
+import { Agreement, AgreementLine } 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 {
+    agreementId: string;
+    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.
+ */
+export interface PurchaseAgreementLine extends AgreementLine {
+    /** Provenance only: the offer it was bought on. The price is `price`, not the offer's. */
+    offerId?: string;
+    /** Their subscription id (Pax8, Microsoft). */
+    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;
+    };
+    customerCompanyId?: string;
+    /** The sales line that passes this on, followed by series. */
+    salesLine?: SalesLineRef;
+    /**
+     * `variable`: no price, the invoice decides the amount (transit minutes). Nothing is expected;
+     * only a jump against the last three months is work. A varying *count* (seats) is `quantity:
+     * manual|meter` with a fixed price instead — never this.
+     */
+    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. */
+    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[];
+}
+export interface ExpectedLine {
+    lineId: string;
+    kind: "fixed" | "count" | "variable";
+    /** Fixed lines only; a count waits for the count, a variable line expects nothing. */
+    cents?: Cents;
+}
+/**
+ * What the supplier should invoice over `window`, per line: a fixed count at the agreed price over
+ * 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[];
+/**
+ * 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.
+ */
+export declare function variableJump(previous: readonly Cents[], current: Cents, threshold?: number): boolean;
+/** A sales line as sales reports it now, by series. */
+export interface SalesLineState extends SalesLineRef {
+    /** Fixed count now; `null` for a count from a meter or entered per period. */
+    quantity: number | null;
+    /** When it really ends if the customer gives notice today. */
+    effectiveEndAt: number;
+    /** Windows due now without an invoice line (`agreementLineId` + `servicePeriod`). */
+    unbilled: Period[];
+    /** The sales line has ended or its agreement is not active. */
+    ended?: boolean;
+}
+export type ContractSignal = {
+    kind: "not_covered";
+    contractId: string;
+    lineId: string;
+    reason: "no_sales_line" | "quantity" | "sales_ended";
+} | {
+    kind: "not_billed";
+    contractId: string;
+    lineId: string;
+    windows: Period[];
+} | {
+    kind: "term_mismatch";
+    contractId: string;
+    lineId: string;
+    purchaseEnd: number;
+    salesEnd: number;
+} | {
+    kind: "notice_due";
+    contractId: string;
+    lineId: string;
+    deadline: number;
+} | {
+    kind: "change_window";
+    contractId: string;
+    lineId: string;
+    closesAt: number;
+} | {
+    kind: "variable_jump";
+    contractId: string;
+    lineId: string;
+    cents: Cents;
+};
+export interface SignalOptions {
+    /** A notice deadline this close is a reminder. */
+    noticeDays?: number;
+    /** A change window closing this soon is a reminder. */
+    windowDays?: number;
+}
+/**
+ * Everything about a supplier contract a person should look at, apart:
+ * - **not covered**: bought for a customer, but no sales line passes it on, or another count;
+ * - **not billed**: the sales line exists but a period that is due has no invoice line — a sales
+ *   line that exists proves nothing, so this reads what sales actually invoiced;
+ * - **term mismatch**: we are bound longer than the customer is;
+ * - **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[];