@opencxh/domain 1.287.0 → 1.290.0

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/catalog/index.d.ts

@@ -1,3 +1,6 @@
 export * from './codes';
 export * from './pricing';
+export * from './rate-csv';
+export * from './rating';
 export * from './types';
+export * from './usage-source';

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

@@ -33,14 +33,17 @@ export interface ResolvedPrice {
     sourceKey: string;
     ruleId?: string;
 }
+export declare function resolvePrice(product: Product, ctx: PriceContext, rules: readonly PriceRule[]): ResolvedPrice;
+export interface ResolvedRateCard {
+    rateCardId: string;
+    sourceKey: string;
+    ruleId?: string;
+}
 /**
- * The price for this product, for this customer, at this quantity, on this date.
- *
- * Pure, so the screen can compute along while you type and land on the same cent the server
- * stores. A rule that names neither the product nor its category does not apply, however
- * specific its customer is: a discount on "everything" is a decision, not a price rule.
+ * The rate card a `rated` product is billed on for this customer: the same ladder as a price,
+ * over the rules whose outcome is a card, then the product's own card. `null` = it has none.
  */
-export declare function resolvePrice(product: Product, ctx: PriceContext, rules: readonly PriceRule[]): ResolvedPrice;
+export declare function resolveRateCard(product: Product, ctx: PriceContext, rules: readonly PriceRule[]): ResolvedRateCard | null;
 /** The `priceSourceKey` of a price somebody typed themselves. The ladder never overwrites it. */
 export declare const MANUAL_PRICE_SOURCE = "manual";
 /**

package/dist/entities/catalog/rate-csv.d.ts

@@ -0,0 +1,29 @@
+import { Micros, Rate, RatePrice } from './rating';
+import { UsageMeter } from './usage-source';
+/**
+ * A rate deck as CSV, one rate per line, with columns that follow the meter:
+ *
+ *     label;<one column per dimension>;setup;price[;increment;minimum]
+ *     Nederland mobiel;316;outbound;0,0450;0,0650;60/1;60      (calls: destination, direction)
+ *     Internet uit;eu-west-1;;+12%                              (traffic: region, direction)
+ *
+ * `;` or `,` separated (a Dutch Excel writes `;` because `,` is its decimal mark); a first line
+ * whose price column is not a price is a header. The price is per `meter.display` unit, written
+ * with either decimal mark, or `+12%` for a markup on cost. An empty dimension matches anything.
+ * Increment and minimum only exist when the meter bills per record (`display.per > 1`). Tiers
+ * are edited on screen, not in a file.
+ */
+export interface RateCsvResult {
+    rates: Omit<Rate, "id">[];
+    errors: {
+        line: number;
+        message: string;
+    }[];
+}
+/** `"0,0450"` → 45 000 micros, without a float in between. */
+export declare function parseMicros(value: string): Micros | undefined;
+/** 45 000 micros → `"0,0450"`: at least four decimals, more only when the rate has them. */
+export declare function formatMicros(micros: Micros): string;
+/** `"+12%"` → a markup; a plain amount → a flat price; anything else → `undefined`. */
+export declare function parseRatePrice(value: string): RatePrice | undefined;
+export declare function parseRateCsv(text: string, meter: UsageMeter): RateCsvResult;

package/dist/entities/catalog/rate-csv.test.d.ts

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

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

@@ -0,0 +1,122 @@
+import { Cents } from '../money/money';
+/**
+ * Pricing records on a rate card: a call, a text, a gigabyte of traffic, an hour of compute.
+ *
+ * Each record is matched to one rate on its dimensions; the records of a rate are then summed
+ * (or averaged, per the meter) and priced as a group — flat, tiered, or as a markup on cost.
+ * Carriers and clouds quote in four or five decimals, so rates are in **micros** (millionths of
+ * the currency unit); only a group's total becomes cents.
+ */
+export type Micros = number;
+export declare const MICROS_PER_CENT = 10000;
+/**
+ * One usage record as a source reports it: a real event (a call) or a summary (GB transferred
+ * in a region on one day) — a source with millions of events sends summaries.
+ */
+export interface UsageRecord {
+    id: string;
+    meter: string;
+    /** In the meter's unit: seconds for a call, bytes or GB for traffic, seats for licences. */
+    quantity: number;
+    /** Whatever the meter declares: `direction`, `destination`, `region`, … */
+    dimensions: Record<string, string>;
+    occurredAt: number;
+    /** What the source paid for it. Needed by a markup rate; kept for a later margin view. */
+    costMicros?: Micros;
+}
+/** How a period's records become one number: calls add up, licences take their peak. */
+export type UsageAggregation = "sum" | "max" | "last" | "average";
+export declare function aggregateUsage(records: readonly {
+    quantity: number;
+    occurredAt?: number;
+}[], aggregation: UsageAggregation): number;
+/** `equals` pins a value; `prefix` takes the longest match (a number range, a region family). */
+export type RateMatcher = {
+    equals: string;
+} | {
+    prefix: string;
+};
+export type RatePrice = 
+/** The price of `unitSize` units. */
+{
+    kind: "flat";
+    micros: Micros;
+}
+/**
+ * Bands over the group's quantity. `graduated`: every band at its own price. `volume`: the whole
+ * quantity at the price of the band it lands in. The last band has no `upTo`.
+ */
+ | {
+    kind: "tiered";
+    mode: "graduated" | "volume";
+    tiers: {
+        upTo?: number;
+        micros: Micros;
+    }[];
+}
+/** The source's cost plus a percentage. A record without a cost has no price. */
+ | {
+    kind: "markup";
+    percent: number;
+};
+export interface Rate {
+    /** Unique within its card. */
+    id: string;
+    /** What the invoice line says: "Nederland mobiel", "Internet uit · eu-west-1". */
+    label: string;
+    /** Per dimension. A dimension not named matches anything. */
+    match: Record<string, RateMatcher>;
+    /** Once per record with a quantity above zero. */
+    setupMicros: Micros;
+    price: RatePrice;
+    /** How many meter units a price is for: 60 seconds, 3600 seconds, a million requests. */
+    unitSize: number;
+    /** Rounding per record: 60 / 1 bills the first 60 units whole, then each unit. 1/1 = none. */
+    firstIncrement: number;
+    nextIncrement: number;
+    /** At least this many units per record. */
+    minimum: number;
+    /** Free units per period, taken off the group before its price. */
+    included?: number;
+}
+/** `+31 6-1234`, `0031 61234` and `31612 34` are all `3161234`. */
+export declare function digitsOf(value: string): string;
+export declare function matchRate(record: UsageRecord, rates: readonly Rate[]): Rate | undefined;
+export declare function billedQuantity(quantity: number, rate: Rate): number;
+export interface PriceBand {
+    quantity: number;
+    micros: Micros;
+}
+/** A tiered price over `quantity` meter units, with the bands it used. */
+export declare function tieredMicros(quantity: number, price: Extract<RatePrice, {
+    kind: "tiered";
+}>, unitSize: number): {
+    micros: Micros;
+    bands: PriceBand[];
+};
+export interface RatedGroup {
+    rateId: string;
+    label: string;
+    records: number;
+    /** The records it holds, so an invoice can claim them (time entries). */
+    recordIds: string[];
+    /** After per-record rounding and the meter's aggregation, before `included`. */
+    measured: number;
+    included: number;
+    /** What is priced: `measured - included`, never below zero. */
+    billed: number;
+    micros: Micros;
+    cents: Cents;
+    /** The bands of a tiered price, for the invoice. */
+    bands?: PriceBand[];
+}
+export interface RatingResult {
+    groups: RatedGroup[];
+    /**
+     * Records no rate matched, or matched a markup without a cost. The caller decides, out loud,
+     * whether to bill without them — usage is never silently free.
+     */
+    unrated: UsageRecord[];
+}
+/** A period's records, rated and grouped per rate. Cents are rounded once per group. */
+export declare function rateRecords(records: readonly UsageRecord[], rates: readonly Rate[], aggregation?: UsageAggregation): RatingResult;

package/dist/entities/catalog/rating.test.d.ts

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

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

@@ -44,6 +44,13 @@ export interface Product {
      * type: time must not know sales, and several products may share one type (junior/senior).
      */
     workTypeKey?: string;
+    /**
+     * `unit`: a price per unit through the ladder (list price, tiers, customer agreements).
+     * `rated`: every record priced on a rate card by its dimensions (calls, traffic).
+     */
+    pricing?: ProductPricing;
+    /** The default card of a `rated` product. A price agreement may name another. */
+    rateCardId?: string;
     /** See {@link FIXED_UNITS}. Drives the form and the word after the quantity. */
     unitKey: string;
     /** Key into the organisation's VAT table, never the percentage itself. */
@@ -78,7 +85,8 @@ export interface Product {
  * 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 declare const FIXED_UNITS: readonly ["piece", "hour", "day", "month", "km", "license"];
+export type ProductPricing = "unit" | "rated";
+export declare const FIXED_UNITS: readonly ["piece", "hour", "day", "month", "km", "license", "minute"];
 export type FixedUnit = (typeof FIXED_UNITS)[number];
 /**
  * A price for a customer, a segment or a contract.
@@ -98,9 +106,13 @@ export interface PriceRule {
     segmentKey?: string;
     /** From which quantity. Absent = from one. */
     minQuantity?: number;
-    /** Exactly one of the two. A fixed price beats a discount when both would apply. */
+    /**
+     * Exactly one outcome. A fixed price beats a discount; a rate card is the outcome for a `rated`
+     * product ("this customer calls on Enterprise") and is ignored by the unit ladder.
+     */
     unitPriceCents?: Cents;
     discountPercent?: number;
+    rateCardId?: string;
     currency: string;
     validFrom?: number;
     validTo?: number;
@@ -114,6 +126,29 @@ export interface PriceRule {
     createdBy: string;
     createdAt?: number;
 }
+/**
+ * A price list for usage: which meter it prices, in which currency, from when. The rates travel
+ * separately (`rate-card/:id/rates`) — a carrier's deck has thousands of rows and a list of cards
+ * must not carry them.
+ */
+export interface RateCard {
+    id: string;
+    organizationId: string;
+    name: string;
+    /** The app that reports the usage (`eylo-voip`) and its meter key (`eylo.call`). */
+    sourceApp: string;
+    meter: string;
+    /** Kept with the rates, so the list can show it without loading them. */
+    rateCount?: number;
+    currency: string;
+    validFrom?: number;
+    validTo?: number;
+    businessEntityId?: string;
+    archived?: boolean;
+    createdBy: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
 /**
  * What the product form sends. Everything optional but the name: the server fills defaults, and
  * a form that has to send a complete product cannot add a variant with two fields.
@@ -125,3 +160,7 @@ export interface SaveProductRequest extends Partial<Omit<Product, "id" | "organi
 export interface SavePriceRuleRequest extends Partial<Omit<PriceRule, "id" | "organizationId" | "createdBy" | "createdAt">> {
     id?: string;
 }
+export interface SaveRateCardRequest extends Partial<Omit<RateCard, "id" | "organizationId" | "createdBy" | "createdAt" | "updatedAt">> {
+    id?: string;
+    name: string;
+}

package/dist/entities/catalog/usage-source.d.ts

@@ -0,0 +1,83 @@
+import { LocaleBundle } from '../../platform/localization';
+import { UsageAggregation, UsageRecord } from './rating';
+/**
+ * Role group of an app whose usage can be billed: calls, texts, gigabytes.
+ *
+ * A constant for the same reason as `ONBOARDING_SOURCE_PROVIDER_GROUP`: an unknown group answers
+ * with an empty list, so a typo reads as "nothing to bill".
+ */
+export declare const USAGE_SOURCE_PROVIDER_GROUP = "usage-source";
+/** Route under the provider scope that returns a period's records. App-only. */
+export declare const USAGE_RECORDS_ROUTE = "/usage/records";
+export interface UsageMeter {
+    /** Namespaced by the owner, like analytics metrics: `eylo.call`, never `call`. */
+    key: string;
+    /** An i18n key from the source's `locales`. */
+    label: string;
+    /** What `UsageRecord.quantity` counts: `second`, `message`, `gigabyte`, `seat`. */
+    unit: string;
+    /**
+     * How a person reads it: `{ unit: "minute", per: 60 }` prices seconds per minute. `per > 1` is
+     * also what makes per-record rounding (60/1) and a minimum worth showing.
+     */
+    display: {
+        unit: string;
+        per: number;
+    };
+    /** How a period's records become one number: calls `sum`, licences `max`, storage `average`. */
+    aggregation: UsageAggregation;
+    /** What a rate may match on; `prefix` for number ranges and families, `exact` otherwise. */
+    dimensions: UsageDimension[];
+    /**
+     * Whose usage it is. `source`: one of the source's own accounts (a PBX tenant), picked on the
+     * agreement. `customer`: the agreement's customer itself — hours booked on a company — so there
+     * is nothing to pick, and the customer's id is the account. Absent = `source`.
+     */
+    account?: "source" | "customer";
+}
+export interface UsageDimension {
+    key: string;
+    label: string;
+    match: "exact" | "prefix";
+    /**
+     * The values it takes, when that is a known list: a rate then picks one instead of typing it,
+     * and a typo cannot silently match nothing. `label` is a key in the source's `locales`, or
+     * plain text for values the organisation named itself (a work type).
+     */
+    options?: {
+        value: string;
+        label: string;
+    }[];
+}
+export interface UsageSourceDescription {
+    meters: UsageMeter[];
+    /**
+     * The accounts usage can be read for: a PBX tenant, a sms sender. The agreement binds one to a
+     * customer; the source never learns about customers.
+     */
+    accounts: {
+        ref: string;
+        name: string;
+    }[];
+    locales?: LocaleBundle;
+}
+export interface UsageRecordsRequest {
+    meter: string;
+    accountRef: string;
+    /** Epoch ms, `to` exclusive. */
+    from: number;
+    to: number;
+}
+export interface UsageRecordsResponse {
+    records: UsageRecord[];
+}
+/**
+ * A meter as another app described it, made whole. A describe crosses an app boundary and may be
+ * older than this contract (a source not redeployed yet, a cached describe): missing fields get
+ * the neutral answer — its own unit per 1, summed, matched exactly — instead of crashing a screen.
+ */
+export declare function normalizeMeter(raw: Partial<UsageMeter> & {
+    key: string;
+}): UsageMeter;
+/** Every meter of a describe made whole; see {@link normalizeMeter}. */
+export declare function normalizeUsageSource<T extends UsageSourceDescription>(source: T): T;

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 {};