@opencxh/domain 1.293.0 → 1.295.0

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`. */
@@ -86,10 +133,50 @@ export interface ReceiptLine {
     /** The account in the target books (`LedgerOption.key`). */
     accountKey?: string;
     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
+ * is then the group's cost account), or a prepaid cost released over months (its account is
+ * prepaid costs). Made once, when the receipt is handed to the books.
+ */
+export type ReceiptLineTreatment = {
+    kind: "asset";
+    groupId: string;
+    name?: string;
+    identifier?: string;
+    assignedUserId?: string;
+    quantity?: number;
+    aiSuggested?: boolean;
+} | {
+    kind: "spread";
+    months: number;
+    /** The first month released, as its first day. */
+    firstMonth: string;
+    resultAccountId: string;
+};
+/**
+ * Proposes "activate" for a line at or above the threshold whose account is a group's cost
+ * account: the reader picked a fixed-asset account, the amount says it is one. Never overrides
+ * what a person chose; without a threshold (no rule for the country) it proposes nothing.
+ */
+export declare function suggestTreatments(lines: readonly ReceiptLine[], groups: readonly {
+    id: string;
+    costAccountId: string;
+}[], 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";
+export type ReceiptProblem = "no_supplier" | "no_date" | "no_lines" | "no_account" | "asset_without_group" | "spread_without_months";
 export declare const RECEIPT_SCOPE_KIND = "receipt";
 /** The act a sign-off on a receipt is about. */
 export declare const RECEIPT_BOOK_ACT = "book";
@@ -99,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/schedule.d.ts

@@ -52,10 +52,31 @@ type PlannedPosting = Omit<ScheduledPosting, "id" | "organizationId" | "business
 export declare function monthEnd(day: string): string;
 /** `totalCents` over `months` equal parts; the last takes the rounding, so the parts add up exactly. */
 export declare function spread(totalCents: Cents, months: number): Cents[];
-/** Straight-line depreciation: (cost − residual) over the life, from the month of acquisition. */
+/**
+ * The monthly amounts, from the acquisition (or the restart after a revision) on. Linear spreads
+ * (start − residual) over the months left; declining takes the monthly share of a yearly
+ * percentage of the book value until the residual is reached, the last month exactly; none is
+ * nothing. The sum is always start − residual, never below the residual.
+ */
+export declare function depreciationParts(t: FixedAssetTerms): Cents[];
+/** Depreciation per month by the asset's method; a disposed asset plans nothing more. */
 export declare function depreciationPostings(item: Pick<FinancingItem, "id" | "name"> & {
     terms: FixedAssetTerms;
 }, through: string): PlannedPosting[];
+/**
+ * The memorial entry that takes an asset off the books: its cost and accumulated depreciation
+ * off (both on the item, so it ends at nil), the proceeds on the clearing account the sales
+ * invoice books against, and the difference on the group's disposal account.
+ */
+export declare function disposalLines(item: Pick<FinancingItem, "id" | "name" | "ledgerAccountId"> & {
+    terms: FixedAssetTerms;
+}, input: {
+    /** The item's booked movements: its accumulated depreciation, negative. */
+    movementsCents: Cents;
+    proceedsCents: Cents;
+    clearingAccountId: string;
+    disposalAccountId: string;
+}): PlannedPosting["lines"];
 /** A transitorium released month by month onto its result account. */
 export declare function accrualPostings(item: Pick<FinancingItem, "id" | "name" | "ledgerAccountId"> & {
     terms: AccrualTerms;
@@ -70,4 +91,22 @@ export declare function startingCents(terms: FixedAssetTerms | AccrualTerms): Ce
  * show it as a short-term liability (aflossingsverplichting), the rest as long-term.
  */
 export declare function shortTermPrincipal(terms: Pick<LoanTerms, "principalCents" | "ratePercent" | "method" | "termMonths" | "firstDueOn">, yearEnd: string): Cents;
+/**
+ * Part of a batch leaving: its share (quantity / the batch) of cost and accumulated depreciation
+ * comes off. The accumulated share leaves the item's sub-account; the cost share leaves the cost
+ * account without it, because the item's cost is its terms — they shrink by the same share.
+ */
+export declare function partialDisposalLines(item: Pick<FinancingItem, "id" | "name" | "ledgerAccountId"> & {
+    terms: FixedAssetTerms;
+}, input: {
+    quantity: number;
+    movementsCents: Cents;
+    proceedsCents: Cents;
+    clearingAccountId: string;
+    disposalAccountId: string;
+}): {
+    lines: PlannedPosting["lines"];
+    costCents: Cents;
+    residualCents: Cents;
+};
 export {};

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

@@ -50,10 +50,12 @@ export interface DepositTerms {
     kind: "deposit_paid";
     refundableOn?: string;
 }
+/** Straight-line over the life, a yearly percentage of the book value, or none (land). */
+export type DepreciationMethod = "linear" | "declining" | "none";
 /**
- * A fixed asset, depreciated straight-line per month from the month it was acquired. The item
- * sits under the cost account; depreciation lands on the accumulated-depreciation account, so the
- * annual accounts show cost and accumulated apart. Acquisition itself is booked by its invoice.
+ * A fixed asset, depreciated per month from the month it was acquired. The item sits under the
+ * cost account; depreciation lands on the accumulated-depreciation account, so the annual accounts
+ * show cost and accumulated apart. Acquisition itself is booked by its invoice.
  */
 export interface FixedAssetTerms {
     kind: "fixed_asset";
@@ -61,11 +63,95 @@ export interface FixedAssetTerms {
     costCents: Cents;
     residualCents: Cents;
     lifeMonths: number;
+    /** Absent on assets made before methods existed: linear. */
+    method?: DepreciationMethod;
+    /** `declining`: the yearly percentage of the book value, as a decimal string (`"25"`). */
+    ratePercent?: string;
     /** Expense: `Afschrijving inventaris`. */
     depreciationAccountId: string;
     /** Contra-asset: `Afschrijving inventaris` under the fixed assets. */
     accumulatedAccountId: string;
+    /** Register: the group it came from, what identifies it, where it is and who uses it. */
+    groupId?: string;
+    /** A licence plate, a serial number, an address. */
+    identifier?: string;
+    location?: string;
+    assignedUserId?: string;
+    /** A batch (12 laptops) is one asset with a quantity. */
+    quantity?: number;
+    /**
+     * A revision (new life, residual or method) from a month on: the schedule starts over from the
+     * book value then, numbered on from `fromSequence`, so the terms already posted stay as they are.
+     */
+    restart?: {
+        fromMonth: string;
+        bookValueCents: Cents;
+        fromSequence: number;
+    };
+    /**
+     * Part of a batch that left (3 of 12 laptops): each took its share of cost, residual and
+     * accumulated depreciation off; `costCents`, `residualCents` and `quantity` are what is left.
+     */
+    partialDisposals?: {
+        on: string;
+        quantity: number;
+        reason: "sold" | "scrapped" | "lost";
+        costCents: Cents;
+        proceedsCents: Cents;
+        buyerCompanyId?: string;
+        entryId?: string;
+    }[];
+    /** Sold, scrapped or lost: booked once, and the schedule stops. */
+    disposal?: {
+        on: string;
+        reason: "sold" | "scrapped" | "lost";
+        proceedsCents: Cents;
+        buyerCompanyId?: string;
+        entryId?: string;
+    };
 }
+/**
+ * A kind of fixed asset (plan 041 §2): a flat list per administration, no tree. A new asset takes
+ * its accounts, method and life from the group; an asset may differ from it.
+ */
+export interface AssetGroup {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    name: string;
+    costAccountId: string;
+    /** Absent for a group that is not depreciated (land). */
+    accumulatedAccountId?: string;
+    depreciationAccountId?: string;
+    /** Where a disposal's gain or loss lands: `Boekresultaat vervoermiddelen`. */
+    disposalAccountId: string;
+    method: DepreciationMethod;
+    lifeMonths?: number;
+    ratePercent?: string;
+    residualPercent?: string;
+    archived?: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/**
+ * Below this a purchase is a cost, at or above it a fixed asset: per country, an administration
+ * may set its own. Only the Netherlands is filled in (€ 450, the fiscal rule); a country comes
+ * with its country pack. Known, not built: DE € 800 (GWG), FR € 500 HT, US $ 2,500 (de minimis).
+ * BE and UK have no statutory threshold: their own valuation rules decide.
+ */
+export declare const CAPITALIZATION_THRESHOLD_CENTS: Readonly<Record<string, Cents>>;
+export declare const capitalizationThreshold: (country?: string, own?: Cents) => Cents | undefined;
+/** The groups a new administration starts with, by template account code. */
+export declare const ASSET_GROUP_SEEDS: readonly {
+    name: string;
+    cost: string;
+    accumulated?: string;
+    depreciation?: string;
+    disposal: string;
+    method: DepreciationMethod;
+    lifeMonths?: number;
+    residualPercent?: string;
+}[];
 /**
  * An amount spread over months (transitoria): prepaid insurance released to costs, revenue
  * invoiced ahead released to revenue, costs accrued before their invoice. `expense` debits the
@@ -82,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 {
@@ -101,6 +195,8 @@ export interface FinancingItem {
     openedOn?: string;
     closedOn?: string;
     archived?: boolean;
+    /** Made from a document line (`receipt:<id>:<line>`): once per line. */
+    sourceKey?: string;
     createdAt?: number;
     updatedAt?: number;
 }

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;