@opencxh/domain 1.288.0 → 1.290.0

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

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

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

@@ -0,0 +1,3 @@
+export * from './match';
+export * from './parse';
+export * from './types';

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

@@ -0,0 +1,52 @@
+import { Cents } from '../money/money';
+import { BankLine, BankRule, MatchProposal, Reconciliation } from './types';
+/**
+ * A proposal for one bank line, in the order of the datamodel (§6.1): a reference with the
+ * amount, then an IBAN with the amount, then a transfer between own accounts, then a rule.
+ * Nothing guessed: no proposal is better than a wrong one in "Klaar om te bevestigen".
+ */
+/** An open sales invoice (money in) or receipt (money out), with what is still open. */
+export interface OpenDocument {
+    kind: "sales_invoice" | "receipt";
+    id: string;
+    sourceApp?: string;
+    number?: string;
+    /** IBANs this party pays from or to (crm `Company.ibans`, or the receipt's). */
+    ibans: string[];
+    /** Positive: what is still to receive (an invoice) or to pay (a receipt). */
+    openCents: Cents;
+    label: string;
+}
+export interface MatchContext {
+    documents: readonly OpenDocument[];
+    rules: readonly BankRule[];
+    /** Our own accounts, to recognise a transfer. */
+    ownIbans: readonly {
+        iban: string;
+        bankAccountId: string;
+    }[];
+    /** Instalments waiting for their bank line: the amount to expect, when, and the party's IBANs. */
+    scheduled?: readonly {
+        id: string;
+        expectedBankCents: Cents;
+        dueOn: string;
+        ibans: string[];
+        label: string;
+    }[];
+    /** Unbooked lines on other own accounts, for the other side of a transfer. */
+    otherLines: readonly Pick<BankLine, "id" | "bankAccountId" | "date" | "amountCents" | "state">[];
+}
+export declare function proposeMatch(line: Pick<BankLine, "bankAccountId" | "date" | "amountCents" | "counterpartyIban" | "description" | "endToEndId">, context: MatchContext): MatchProposal | undefined;
+/** What is left of an item: its amount minus every active allocation on it. Computed, never stored. */
+export declare function openCentsOf(itemKey: string, amountCents: Cents, reconciliations: readonly Pick<Reconciliation, "status" | "allocations">[]): Cents;
+/** The invariant of a reconciliation: its allocations cancel out (a difference is in the entry). */
+export declare function reconciliationBalances(rec: Pick<Reconciliation, "allocations">): boolean;
+/**
+ * The whole payment state of an item from its amount and what is still open, both signed like
+ * 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";
+    paidCents: number;
+    openCents: number;
+};

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

@@ -0,0 +1,13 @@
+import { ParsedStatement } from './types';
+/** Every `<tag>…</tag>` body at any depth, in order. Tags are matched by local name. */
+declare function blocks(xml: string, tag: string): string[];
+/** The text at a path of tags: `first(x, "BookgDt", "Dt")`. */
+declare function first(xml: string, ...path: string[]): string | undefined;
+/** ISO 20022 camt.053: one statement per file is the common case; every `Stmt` is read. */
+export declare function parseCamt053(input: string): ParsedStatement;
+/** SWIFT MT940, as Dutch banks export it. Several statements in one file are read in order. */
+export declare function parseMt940(input: string): ParsedStatement;
+/** Which format a file is in, by its content, not its name. */
+export declare function parseStatement(input: string): ParsedStatement;
+/** The same scanner for other flat XML the browser reads (the XAF import). */
+export { blocks as xmlBlocks, first as xmlText };

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

@@ -0,0 +1,197 @@
+import { Cents } from '../money/money';
+/**
+ * Bank accounts, statements and their lines, and settling one with the other (plan 039
+ * datamodel §5.1, §6.1–6.3). Only the bank kinds of `SubAccount` are built here; loans, the
+ * director's current account and participations follow in step 6b on the same row.
+ */
+export type BankSubAccountKind = "bank" | "savings" | "deposit" | "credit_card" | "psp" | "cash";
+/** A bank account (or cash, a card, a payment provider balance) under a ledger account. */
+export interface BankAccount {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    kind: BankSubAccountKind;
+    name: string;
+    /** The ledger account it sits under (`1100 Bank`), and the bank journal its lines post in. */
+    ledgerAccountId: string;
+    journalId: string;
+    iban?: string;
+    currency: string;
+    archived?: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface BankImport {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    bankAccountId: string;
+    format: "camt053" | "mt940";
+    from: string;
+    to: string;
+    /** What the statement says. A difference with our balance is a signal, never a silent fix. */
+    statementOpeningCents?: Cents;
+    statementClosingCents?: Cents;
+    lineCount: number;
+    importedBy: string;
+    createdAt?: number;
+}
+/** A line as a parser reads it from a statement, before it is stored. */
+export interface ParsedBankLine {
+    date: string;
+    valueDate?: string;
+    /** Positive = money in. */
+    amountCents: Cents;
+    currency: string;
+    counterpartyName?: string;
+    counterpartyIban?: string;
+    description: string;
+    endToEndId?: string;
+    /**
+     * Unique per account: the bank's own reference (CAMT `AcctSvcrRef`, MT940 `:61:` reference), or
+     * else statement number + line number. Never date + amount + text alone: two coffees of € 3,20
+     * on one day are two lines.
+     */
+    dedupeKey: string;
+}
+export interface ParsedStatement {
+    format: BankImport["format"];
+    iban?: string;
+    currency?: string;
+    from: string;
+    to: string;
+    openingCents?: Cents;
+    closingCents?: Cents;
+    lines: ParsedBankLine[];
+}
+/** What a bank line is paired with. The pair lives on the line only; nothing points back. */
+export type MatchTarget = {
+    kind: "sales_invoice";
+    transactionId: string;
+    sourceApp: string;
+} | {
+    kind: "receipt";
+    receiptId: string;
+}
+/** A prepared posting from a balance item's schedule: a loan instalment. */
+ | {
+    kind: "scheduled_posting";
+    scheduledPostingId: string;
+}
+/** The other side of a transfer between two own accounts. */
+ | {
+    kind: "transfer";
+    bankLineId: string;
+}
+/** Straight to an account (bank costs, a rule). */
+ | {
+    kind: "account";
+    accountId: string;
+    taxCode?: string;
+    description?: string;
+};
+export type MatchReason = "amount" | "iban" | "reference" | "invoice_number" | "date_window" | "rule" | "own_account";
+export interface MatchProposal {
+    target: MatchTarget;
+    via: "exact" | "rule" | "manual";
+    confidence: "high" | "medium" | "low";
+    ruleId?: string;
+    /** What agreed, for the explanation on screen: "same amount, same IBAN". */
+    reasons: MatchReason[];
+    /** What the target is called, so the queue need not look it up: "F2026-0190 · Studio Noord". */
+    label?: string;
+}
+export interface BankLine extends ParsedBankLine {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    bankAccountId: string;
+    importId: string;
+    /** Computed at import and after, stored so the queue loads fast. */
+    proposal?: MatchProposal;
+    /** unmatched → booked (entry and reconciliation written) · ignored. */
+    state: "unmatched" | "booked" | "ignored";
+    /** What it was booked against, and the entry that did it. */
+    pairedWith?: MatchTarget;
+    entryId?: string;
+    /**
+     * How often it was booked and undone: the entry's source key is `bank:<id>:<attempt>`, so booking
+     * again after an undo makes a new entry instead of finding the reversed one.
+     */
+    attempt?: number;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/** Made by a person, or offered after a manual pairing ("Voortaan automatisch?"). */
+export interface BankRule {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    name: string;
+    /** Every condition given must hold. */
+    when: {
+        bankAccountId?: string;
+        counterpartyIban?: string;
+        /** Case-insensitive, in memory (the store has no `$regex`). */
+        descriptionContains?: string;
+        direction?: "in" | "out";
+    };
+    action: {
+        accountId: string;
+        taxCode?: string;
+        description?: string;
+    };
+    /** High lands in "Klaar om te bevestigen", medium in "Controleren". */
+    confidence: "high" | "medium";
+    order: number;
+}
+/** An item that can be open: a posted line (debtor, creditor), or a bank line. */
+export type OpenItemRef = {
+    kind: "journal_line";
+    id: string;
+} | {
+    kind: "bank_line";
+    id: string;
+};
+/**
+ * One reconciliation: amounts that cancel out. Immutable once active; undoing sets `reversed`
+ * and deletes nothing, so the history stays (datamodel §6.3).
+ */
+export interface Reconciliation {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    /** `bank:<bankLineId>` while active; a reversed one gets `:reversed:<at>` so the line can pair again. Unique. */
+    reconKey: string;
+    kind: "payment" | "credit_offset" | "transfer" | "write_off" | "manual";
+    /**
+     * The sign follows the item: a debtor line is +, its receipt −. The allocations cancel out; a
+     * difference is booked in the payment's entry and listed below for the audit.
+     */
+    allocations: {
+        item: OpenItemRef;
+        amountCents: Cents;
+    }[];
+    differences?: {
+        amountCents: Cents;
+        reason: "payment_difference" | "bank_costs" | "fx" | "write_off";
+        accountId: string;
+        entryId: string;
+    }[];
+    /** Flat and indexed: which reconciliations touch this item is an `$in` on this field. */
+    itemKeys: string[];
+    status: "active" | "reversed";
+    origin: {
+        via: "exact" | "rule" | "manual";
+        ruleId?: string;
+        proposalReasons?: MatchReason[];
+    };
+    createdBy: string;
+    createdAt?: number;
+    reversal?: {
+        at: number;
+        by: string;
+        reason: string;
+    };
+}
+export declare const itemKeyOf: (item: OpenItemRef) => string;

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

@@ -0,0 +1,2 @@
+export * from './receipt';
+export * from './types';

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

@@ -0,0 +1,104 @@
+import { BookingDocument } from '../../platform/bookkeeping';
+import { Cents } from '../money/money';
+import { TaxRateKind } from '../money/tax';
+import { WorkQueueItem } from './types';
+/**
+ * A receipt or purchase invoice, as finance holds it until it is booked (plan 039 datamodel §6.4).
+ * Finance is its own `bookable-source` for these, so a receipt reaches Jortt the way an invoice
+ * does, through the same `BookingSync`.
+ */
+export interface Receipt {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    /**
+     * Where it came from, flat and unique: `mail:<activityId>:<attachmentId>` or
+     * `upload:<fileId>`. The same attachment sent to the macro twice is one receipt.
+     */
+    sourceKey: string;
+    /** The copy in storage: the books keep it seven years, a mailbox does not. */
+    file: {
+        mountId: string;
+        fileId: string;
+        filename: string;
+        mimeType: string;
+    };
+    receivedVia: "mail" | "upload";
+    receivedAt: number;
+    mail?: {
+        interactionId: string;
+        activityId: string;
+        from?: string;
+        subject?: string;
+    };
+    supplierCompanyId?: string;
+    fields: ReceiptFields;
+    lines: ReceiptLine[];
+    totals: {
+        netCents: Cents;
+        taxCents: Cents;
+        grossCents: Cents;
+    };
+    status: ReceiptStatus;
+    /** Why extraction gave nothing, when it did not: shown on the item, a person fills it in. */
+    extractError?: string;
+    /** Only the reference; the state lives on the approval request (one approval system, plan 023). */
+    approvalRequestId?: string;
+    /** When it was handed to the books: the "issue" moment the sweeper and `activeFrom` go by. */
+    bookedAt?: number;
+    postedAt?: number;
+    externalIds?: string[];
+    createdBy?: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/**
+ * extracting: the AI is reading it.
+ * to_check: something is filled in and not confirmed yet.
+ * awaiting_approval: confirmed, above the administration's threshold, waiting on a sign-off.
+ * booked: handed to the books (the `BookingSync` says whether it arrived).
+ * rejected: not a receipt, or a duplicate.
+ */
+export type ReceiptStatus = "extracting" | "to_check" | "awaiting_approval" | "booked" | "rejected";
+/** A recognised value: whether the AI proposed it, and whether a person has looked. */
+export interface Field<T> {
+    value: T;
+    ai?: boolean;
+}
+export interface ReceiptFields {
+    supplierName?: Field<string>;
+    supplierVatNumber?: Field<string>;
+    supplierIban?: Field<string>;
+    invoiceNumber?: Field<string>;
+    /** `"2026-09-24"`. */
+    issueDate?: Field<string>;
+    dueDate?: Field<string>;
+    currency?: Field<string>;
+}
+export interface ReceiptLine {
+    description?: string;
+    netCents: Cents;
+    taxCents: Cents;
+    /** `TaxCode.key`, e.g. `high`. */
+    taxRateKey: string;
+    taxPercent?: number;
+    taxKind?: TaxRateKind;
+    /** The account in the target books (`LedgerOption.key`). */
+    accountKey?: string;
+    aiSuggested?: boolean;
+}
+/** 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 declare const RECEIPT_SCOPE_KIND = "receipt";
+/** The act a sign-off on a receipt is about. */
+export declare const RECEIPT_BOOK_ACT = "book";
+/** What still stands between this receipt and the books. Empty = it can be confirmed. */
+export declare function receiptProblems(receipt: Pick<Receipt, "fields" | "lines">): ReceiptProblem[];
+/**
+ * Where it sits in "Te verwerken": ready to confirm when nothing is missing, to check when only
+ * the reading needs a look, to choose when an account is missing (no proposal to confirm).
+ */
+export declare function receiptGroupOf(receipt: Pick<Receipt, "fields" | "lines" | "status">): WorkQueueItem["group"] | null;
+/** 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/receipt.test.d.ts

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

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

@@ -0,0 +1,114 @@
+import { BookingDocument, BookingLine } from '../../platform/bookkeeping';
+import { Cents } from '../money/money';
+/**
+ * Who keeps the books of one administration. One row per administration, stored by finance; no
+ * row means nothing is booked (fail-closed, no fan-out). Switching books is one write on this row.
+ */
+export interface BookkeepingBinding {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    /** The `bookkeeping` provider that receives documents: `finance` (own books) or `jortt`. */
+    app: string;
+    /** `ManagedAccount.id` of the connection; empty for our own books. */
+    accountId?: string;
+    /** Mapping onto an external package's accounts. Our own books use `PostingRule` instead. */
+    ledgerMapping?: LedgerMappingRule[];
+    /** Documents issued before this day stay with the previous books. */
+    activeFrom: string;
+    createdBy: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/** First match wins: product, then category, then VAT code, then the rule without a match. */
+export interface LedgerMappingRule {
+    match: {
+        productId?: string;
+        ledgerCategoryKey?: string;
+        taxRateKey?: string;
+    };
+    /** `BookkeepingDescribe.ledgerOptions[].key`. */
+    targetKey: string;
+    externalTaxCode?: string;
+}
+/**
+ * pending: to do, or to do again.
+ * sending: an attempt runs, or ran and its outcome is unknown.
+ * posted: arrived; `externalId` is known.
+ * failed: worth retrying; `nextAttemptAt` is set.
+ * attention: a lasting refusal (validation, a closed year). Waits for a person.
+ */
+export type BookingSyncState = "pending" | "sending" | "posted" | "failed" | "attention";
+/**
+ * The durable processing state of one document on its way to the books (plan 039 datamodel §3.5):
+ * where "did this arrive, and if not, what was the last attempt?" is written down.
+ */
+export interface BookingSync {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    /** `<bindingId>:<sourceApp>:<documentId>`. Flat and never empty: the unique index. */
+    syncKey: string;
+    bindingId: string;
+    targetApp: string;
+    sourceApp: string;
+    documentId: string;
+    documentKind: BookingDocument["kind"];
+    documentNumber?: string;
+    /** `oc:<documentId>`: sent along, and searched on after a lost response. */
+    correlationKey: string;
+    state: BookingSyncState;
+    attempts: number;
+    /** When the running attempt began. A `sending` older than ten minutes has an unknown outcome. */
+    sendingSince?: number;
+    nextAttemptAt?: number;
+    lastError?: {
+        code: string;
+        message: string;
+        at: number;
+    };
+    externalId?: string;
+    /** The number the books gave the document, when they number it themselves. */
+    externalNumber?: string;
+    postedAt?: number;
+    resolvedVia?: "response" | "lookup";
+    /** The source was told it arrived. False until then, so a retry can find what is still owed. */
+    sourceNotified: boolean;
+    /** Jortt only: the open amount last seen, compared on every poll. */
+    lastSeenDueCents?: Cents;
+    /** A credit note: the invoice it credits, and whether the books settled one with the other. */
+    creditsDocumentId?: string;
+    /** `false` until settled; written only on a credit note, so a query can find what is owed. */
+    creditSettled?: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export declare function bookingSyncKey(bindingId: string, sourceApp: string, documentId: string): string;
+/** Minutes to wait after the nth failed attempt (1-based): 1, 5, 15, 60, then every hour. */
+export declare function retryDelayMinutes(attempts: number): number;
+/** How long a `sending` row may run before its outcome counts as unknown. */
+export declare const SENDING_STALE_MS: number;
+/**
+ * One item in "Te verwerken", derived at read time from the state of its source row — never
+ * stored, so it cannot drift (plan 039 datamodel §6.5). Receipts, bank lines and schedule entries
+ * join as they are built.
+ */
+export interface WorkQueueItem {
+    kind: "booking_sync" | "receipt" | "bank_line";
+    ref: string;
+    group: "failed" | "confirm" | "check" | "choose";
+    title: string;
+    subtitle: string;
+    date: number;
+    amountCents?: Cents;
+    /** Why it is here, as an error code the app translates (`error_<code>`), plus the raw detail. */
+    reason?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * The rule a line books under: product, then category, then VAT code, then the rule without a
+ * match. `undefined` when nothing applies — the caller refuses rather than guessing an account.
+ */
+export declare function ledgerRuleFor(line: Pick<BookingLine, "productId" | "ledgerCategoryKey" | "taxRateKey">, rules: readonly LedgerMappingRule[]): LedgerMappingRule | undefined;

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

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

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

@@ -47,8 +47,26 @@ export interface BusinessEntity {
      * BV and its Belgian sister write different default languages under one workspace.
      */
     locale?: string;
-    /** One per entity: an administration is set up per country and per currency. */
+    /** One per entity: an administration is set up per country and per currency. The books' functional currency. */
     currency?: string;
+    /** ISO 3166-1 alpha-2. Picks the country pack: chart template, tax taxonomy, statutory export. */
+    country?: string;
+    /** Picks the chart template and how equity is laid out. */
+    legalForm?: LegalForm;
+    /** A VAT table (NL/EU) or an external tax engine (US, later). Absent = the table for `country`. */
+    taxProfile?: {
+        strategy: "table";
+        taxonomy: string;
+    } | {
+        strategy: "provider";
+        providerId: string;
+    };
+    /** The month the fiscal year starts, 1 = January. Periods are rows derived from it (plan 039 §4.3). */
+    fiscalYearStartMonth?: number;
+    /** How often VAT is filed. Absent = per quarter, the Dutch default. */
+    vatCadence?: "quarter" | "month" | "year";
+    /** Kleineondernemersregeling: no VAT charged or deducted, so no return. */
+    vatKor?: boolean;
     /** The one a new document lands on. Exactly one row carries it. */
     isDefault?: boolean;
     /** Archived, never deleted: an issued quote names the entity it went out as. */
@@ -58,6 +76,8 @@ export interface BusinessEntity {
     createdAt?: number;
     updatedAt?: number;
 }
+export type LegalForm = "bv" | "nv" | "eenmanszaak" | "vof" | "maatschap" | "stichting" | "vereniging" | "other";
+export declare const LEGAL_FORMS: readonly LegalForm[];
 /** What {@link businessEntitySender} reads. Structural, so the document layer keeps pointing here. */
 export type BusinessEntityLike = Pick<BusinessEntity, "name" | "address" | "vatNumber" | "kvkNumber" | "iban" | "logo" | "footerText">;
 /**

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

@@ -0,0 +1,9 @@
+/**
+ * The two identifiers a bank line and an invoice are matched on, in one canonical form. Stored
+ * normalised on write, compared normalised everywhere: `NL91 abna 0417 1643 00` and
+ * `NL91ABNA0417164300` are one account.
+ */
+export declare function normalizeIban(value: string): string;
+export declare function normalizeVatNumber(value: string): string;
+/** Normalised, blanks dropped, duplicates removed, order kept. */
+export declare function normalizeIbans(values: readonly unknown[]): string[];

package/dist/entities/company/identifiers.test.d.ts

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

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

@@ -1 +1,2 @@
 export * from './types';
+export * from './identifiers';

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

@@ -61,6 +61,15 @@ export interface Company {
      * is created and keeps it from then on, so changing this never rewrites what already went out.
      */
     paymentTermCode?: string;
+    /** Normalised: upper case, no spaces (`NL123456789B01`). */
+    vatNumber?: string;
+    kvkNumber?: string;
+    /** This company's bank accounts, normalised. Flat and indexed: matching a payment looks here. */
+    ibans?: string[];
+    /** `<scheme>:<id>` (`0106:12345678`), for Peppol e-invoicing. */
+    peppolId?: string;
+    debtorNumber?: string;
+    creditorNumber?: string;
     /** Raw, human-readable phone/website as entered, for display. */
     phone?: string;
     website?: string;

package/dist/entities/financing/closing-schedules.test.d.ts

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

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

@@ -0,0 +1,2 @@
+export * from './schedule';
+export * from './types';

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

@@ -0,0 +1,71 @@
+import { Cents } from '../money/money';
+import { AccrualTerms, CurrentAccountTerms, FinancingItem, FixedAssetTerms, LoanTerms, ScheduledPosting } from './types';
+/** `day` plus `months`, on the same day of the month or the last one when it is shorter. */
+export declare function addMonths(day: string, months: number): string;
+export interface Installment {
+    sequence: number;
+    dueOn: string;
+    interestCents: Cents;
+    principalCents: Cents;
+    /** What is still owed after this instalment. */
+    remainingCents: Cents;
+}
+/**
+ * A loan's monthly schedule: annuity (equal payments), linear (equal principal) or bullet
+ * (interest only, principal at the end). Cents are rounded per instalment and the last one takes
+ * what is left, so the principal adds up exactly.
+ */
+export declare function loanSchedule(terms: Pick<LoanTerms, "principalCents" | "ratePercent" | "method" | "termMonths" | "firstDueOn">): Installment[];
+/**
+ * Interest over the daily balance (actual/365): every day's closing balance times the day rate,
+ * rounded once at the end. `movements` are the item's booked lines, signed; the balance before
+ * `from` is what they add up to by then.
+ */
+export declare function interestOnDailyBalance(movements: readonly {
+    date: string;
+    cents: Cents;
+}[], from: string, to: string, ratePercent: string): Cents;
+/** The periods interest is settled over, from `openedOn` up to and including the one holding `through`. */
+export declare function interestPeriods(openedOn: string, through: string, cadence: CurrentAccountTerms["cadence"]): {
+    sequence: number;
+    from: string;
+    to: string;
+}[];
+export declare const EXCESSIVE_LENDING_THRESHOLD_CENTS = 50000000;
+/** Wet excessief lenen: how far the director's debt to the BV is toward the threshold. */
+export declare function excessiveLending(directorOwesCents: Cents, thresholdCents?: number): {
+    over: boolean;
+    ratio: number;
+};
+/**
+ * The postings a loan's schedule asks for, up to `through`: one per instalment, its lines the
+ * interest and the principal (on the loan, with the item as sub-account). A received loan is paid
+ * (the bank line is −), a given loan is received (+).
+ */
+export declare function loanPostings(item: Pick<FinancingItem, "id" | "ledgerAccountId" | "name"> & {
+    terms: LoanTerms;
+}, through: string): Omit<ScheduledPosting, "id" | "organizationId" | "businessEntityId" | "status">[];
+type PlannedPosting = Omit<ScheduledPosting, "id" | "organizationId" | "businessEntityId" | "status">;
+/** The last day of the month `day` falls in. */
+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. */
+export declare function depreciationPostings(item: Pick<FinancingItem, "id" | "name"> & {
+    terms: FixedAssetTerms;
+}, through: string): PlannedPosting[];
+/** A transitorium released month by month onto its result account. */
+export declare function accrualPostings(item: Pick<FinancingItem, "id" | "name" | "ledgerAccountId"> & {
+    terms: AccrualTerms;
+}, through: string): PlannedPosting[];
+/**
+ * Where a fixed asset or transitorium stands without its own opening lines: the booked movements
+ * on the item plus what its terms say was there to begin with (cost, or an amount paid upfront).
+ */
+export declare function startingCents(terms: FixedAssetTerms | AccrualTerms): Cents;
+/**
+ * The part of a loan's principal due within twelve months after `yearEnd`: the annual accounts
+ * 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;
+export {};

package/dist/entities/financing/schedule.test.d.ts

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