@opencxh/domain 1.302.0 → 1.303.0

package/dist/entities/fulfilment/target.d.ts

@@ -0,0 +1,131 @@
+import { ProvisionableOffer, ProvisioningAction, RoleNeed } from '../../platform/provisioning';
+import { Agreement, Commitment } from '../agreement/types';
+import { ItemRequirement, ProvisionedItem, ProvisioningRequest, TargetNotice } from './types';
+/** What an item should become, read from its source now (§3). */
+export interface ItemTarget {
+    action: ProvisioningAction;
+    productId: string;
+    quantity: number;
+    previousQuantity?: number;
+    toProductId?: string;
+    effectiveAt?: number;
+    submitAt?: number;
+    notice?: TargetNotice;
+}
+/** The terms of the contract line that pays for the item (§3): when it can end or go down. */
+export interface SupplyTerms {
+    /** Where its term counts from: the subscription's first line. */
+    start: number;
+    commitment?: Commitment;
+    changeWindowDays?: number;
+}
+/** Why there is no target to send: the decision needs something we do not know (Codex 4). */
+export type TargetBlock = {
+    reason: "decrease_window_unknown";
+    quantity: number;
+}
+/** It is paid for, but the contract's terms could not be read: no end or decrease on a guess. */
+ | {
+    reason: "supply_terms_unknown";
+}
+/** Its provider did not describe itself: what it needs is unknown, so nothing is planned. */
+ | {
+    reason: "provider_unknown";
+}
+/** More than one of something that is not interchangeable: one agreement line per unit (D5). */
+ | {
+    reason: "one_unit_per_item";
+    quantity: number;
+}
+/** The agreement names no administration: nothing is made on a guess (review R6). */
+ | {
+    reason: "entity_required";
+};
+/**
+ * The target of one agreement series against what runs, and which unsent requests it replaces
+ * (§3). Read from the current source, never from an event: twice the same event, or two in the
+ * wrong order, give the same answer — "12 per November, corrected to 11" is 11.
+ *
+ * - no item yet, or a pending one without a request: purchase;
+ * - the series ends: cancel at its end;
+ * - another product: convert;
+ * - another count: change, a decrease outside the supplier's window at the term's end;
+ * - an unsent request for the same act stays; one for another act is superseded;
+ * - a sent request is never withdrawn: a different target queues behind it.
+ */
+export declare function targetOf(input: {
+    agreement: Agreement;
+    seriesId: string;
+    item?: ProvisionedItem;
+    requests: readonly ProvisioningRequest[];
+    /** The contract line that pays for it: an end follows its notice, a decrease its window. */
+    supply?: SupplyTerms;
+    now: number;
+}): {
+    target?: ItemTarget;
+    supersede: string[];
+    blocked?: TargetBlock;
+};
+/** A draft request for one act on one item: the same input gives the same id (§2.2). */
+export declare function draftRequest(input: {
+    item: Pick<ProvisionedItem, "id" | "organizationId" | "businessEntityId">;
+    at: {
+        app: string;
+        offer: string;
+    };
+    target: ItemTarget;
+    after?: string[];
+    /** What was asked on the sale (047 step 8): the item's own purchase carries it. */
+    answers?: {
+        params: Record<string, string>;
+        qualificationId?: string;
+    };
+    revision: string;
+    requestedBy: string;
+    now: number;
+}): ProvisioningRequest;
+/**
+ * An offer whose unit has an identity of its own: it provides, or buys with, a number or a device.
+ * Until items exist per unit (`units: "each"`, review 5c) such an item holds one (D5): three
+ * numbers on one item would be bought as one, and billed as three.
+ */
+export declare const onePerItem: (offer: Pick<ProvisionableOffer, "provides" | "needs"> | undefined) => boolean;
+/**
+ * What an offer needs from other items. A provider that still declares only `requires` (the
+ * account offer it lives under) gets that as an account role, so Eylo keeps working unchanged.
+ */
+export declare function needsOf(offer: ProvisionableOffer | undefined): RoleNeed[];
+/**
+ * What a purchase of `item` sets in motion (§7): per role its offer `needs` for a purchase, bind
+ * an existing item (an account, a kept number nobody uses), or make a `pending` one with a stable
+ * key and a purchase request for it; then the item's own purchase, after those.
+ * `sourceFor` names the offer that provides a role — choosing between suppliers is 045 B.
+ */
+export declare function planFor(input: {
+    item: ProvisionedItem;
+    app: string;
+    offer: string;
+    needs: readonly RoleNeed[];
+    target: ItemTarget;
+    items: ReadonlyMap<string, ProvisionedItem>;
+    /** The requests already there: a pending item that is bound is waited for, not bought again. */
+    requests: readonly ProvisioningRequest[];
+    sourceFor: (need: RoleNeed) => {
+        app: string;
+        offer: string;
+        productId: string;
+    } | undefined;
+    /** The sale's answers, for the item's own request only: what it needs is made without them. */
+    answers?: {
+        params: Record<string, string>;
+        qualificationId?: string;
+    };
+    revision: string;
+    requestedBy: string;
+    now: number;
+}): {
+    requires: ItemRequirement[];
+    newItems: ProvisionedItem[];
+    requests: ProvisioningRequest[];
+    unsourced: string[];
+};

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

@@ -0,0 +1,321 @@
+import { ProvidedResource, ProviderQualification, ProvisioningAction, ProvisioningCommand, ProvisioningResult } from '../../platform/provisioning';
+import { DeliverTo } from '../purchase/types';
+/**
+ * What runs at or for a customer (plan 047 v2): a subscription, an account, a bought number, one
+ * tracked device. One store with independent facets — `sale` (the customer takes it: "Producten
+ * bij klanten"), `supply` (we pay for it), `provides` (what it hands others, by kind) and
+ * `requires` (what it uses, by role). A paid Eylo account has `sale` and `provides` at once.
+ */
+export interface ProvisionedItem {
+    /**
+     * Its key ({@link itemKey}): deterministic, unique per organisation, made before the first
+     * request. The same sales event twice finds the same row, and a relation can name an item
+     * before it is stored.
+     */
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    customerCompanyId: string;
+    productId: string;
+    status: ProvisionedStatus;
+    /** Base units. Hardware with a serial: 1, one row per unit. */
+    quantity: number;
+    serial?: string;
+    /**
+     * `<product>#<serial>` while it runs, its own id once ended ({@link serialKeyOf}): a unique
+     * index, so one serial runs once per organisation (review R6).
+     */
+    serialKey?: string;
+    /** What it uses, per role: the account it runs under, the number it routes. Acyclic. */
+    requires?: ItemRequirement[];
+    /** The ids in `requires`, flat: "who uses this?" is `requiresIds: $in` (review R6). */
+    requiresIds?: string[];
+    /** What it can deliver to others; the role is on the relation, not here. */
+    provides?: ProvidedResource[];
+    /** Where it runs, and the provider's own fields as handed back. */
+    at?: {
+        app: string;
+        offer?: string;
+        externalRef?: string;
+        fulfillment?: Record<string, string>;
+    };
+    /**
+     * Its identity at the supplier, `<app>:<externalRef>` ({@link externalKeyOf}), indexed. Not
+     * unique: an ended item keeps it, and a released number can be bought again.
+     */
+    externalKey?: string;
+    /** The commercial link: only on what the customer takes. */
+    sale?: {
+        agreementId: string;
+        seriesId: string;
+    } | {
+        orderId: string;
+        lineId: string;
+    };
+    /** What we pay for it, if bought: 1:1 with a contract line. */
+    supply?: {
+        contractId: string;
+        lineId: string;
+    };
+    fixedAssetId?: string;
+    /** Keep it when what used it ends: number porting, a move to another platform. */
+    keep?: boolean;
+    /** The first time it became active; a resume does not move it (billing start, §10.2). */
+    activatedAt?: number;
+    /** What the supplier says, polled per subscription. */
+    reported?: ReportedState;
+    since: number;
+    endedAt?: number;
+    updatedAt: number;
+}
+export type ProvisionedStatus = "pending" | "active" | "suspended" | "terminating" | "terminated";
+/** Not ended: counts as a user of what it requires, pending included (§10.3). */
+export declare const LIVE_STATUSES: readonly ProvisionedStatus[];
+export interface ItemRequirement {
+    role: string;
+    itemId: string;
+}
+export interface ReportedState {
+    quantity: number;
+    status: "active" | "suspended" | "ended" | "unknown";
+    termEndsAt?: number;
+    autoRenew?: boolean;
+    /** Microsoft NCE: every add-on has its own window; a decrease only within these. */
+    refundable?: {
+        quantity: number;
+        until: number;
+    }[];
+    scheduled?: {
+        quantity?: number;
+        productId?: string;
+        at: number;
+    };
+    at: number;
+}
+export declare const externalKeyOf: (app: string, externalRef: string) => string;
+/** Kept beside `requires` on every write that sets it. */
+export declare const requiresIdsOf: (requires: readonly ItemRequirement[] | undefined) => string[];
+/** A serial is one identity per product while it runs; an ended row holds its own id. */
+export declare const serialKeyOf: (item: Pick<ProvisionedItem, "id" | "productId" | "serial">, running: boolean) => string;
+/** `sale:<agreement>#<series>`, `order:<order>#<line>[#<serial>]`, `resource:<item>#<role>`. */
+export declare function itemKey(source: {
+    kind: "sale";
+    agreementId: string;
+    seriesId: string;
+} | {
+    kind: "order";
+    orderId: string;
+    lineId: string;
+    serial?: string;
+} | {
+    kind: "resource";
+    itemId: string;
+    role: string;
+}): string;
+/** One act on one item (§2.2). */
+export interface ProvisioningRequest {
+    id: string;
+    organizationId: string;
+    /** Always a real administration: a request without one is refused (review R6). */
+    businessEntityId: string;
+    itemId: string;
+    /** `<itemId>:<action>:<revision>`: a retry and a repeated event give the same id. */
+    requestId: string;
+    action: ProvisioningAction;
+    productId: string;
+    /** Absolute target. */
+    quantity: number;
+    previousQuantity?: number;
+    toProductId?: string;
+    effectiveAt?: number;
+    /** When to send it: a decrease at renewal is sent then, not now. */
+    submitAt?: number;
+    /** Why it is on that day: the notice deadline, a next term, paying on (§3). */
+    notice?: TargetNotice;
+    /** Who performs it; `"manual"` is a person. */
+    app: string;
+    offer: string;
+    params: Record<string, string>;
+    /** The delivery check the sale was made on (047 step 8); its answers are in `params`. */
+    qualificationId?: string;
+    /** Bound by role from what the item requires, then checked by kind (§10.1). */
+    inputs?: {
+        role: string;
+        itemId: string;
+        resource: ProvidedResource;
+    }[];
+    /** Order of concrete acts only; the lasting relation is `ProvisionedItem.requires`. */
+    after: string[];
+    /** What it was computed from: re-read before it goes out (§3). */
+    basedOn: {
+        source: string;
+        revision: string;
+    };
+    /** The PO line's offer as the supplier knows it, set on release (045 D N-3). */
+    supplier?: {
+        vendorSku?: string;
+        termMonths?: number;
+    };
+    /** Who pays and who allowed it: a PO line, or the running contract line (§6). */
+    basis?: {
+        kind: "po_line";
+        orderId: string;
+        lineId: string;
+    } | {
+        kind: "contract_line";
+        contractId: string;
+        lineId: string;
+    };
+    state: RequestState;
+    /** Everything that went out, frozen: a retry sends exactly this. */
+    sent?: SentCommand;
+    result?: ProvisioningResult;
+    /** When it was carried out: the day the books follow, unchanged over every retry. */
+    doneAt?: number;
+    /**
+     * `false` from the moment it is approved until the item and the notices to purchase and sales
+     * are done: a crash in between is picked up again, never left half done.
+     */
+    applied?: boolean;
+    /**
+     * A lost purchase whose listing showed more than one new subscription that fits: a person picks
+     * which is ours (047 step 7). Cleared once it is settled.
+     */
+    candidates?: {
+        externalRef: string;
+        quantity: number;
+        offer: string;
+    }[];
+    /** What it costs, from purchase, before an approval weighs it. Unknown is never zero. */
+    priceCents?: number;
+    requestedBy: string;
+    attempts: number;
+    /**
+     * When the poll looks at it again (indexed): `submitAt` when scheduled, a backoff while it waits
+     * or is out the door. `0` = nothing to do by itself (draft, settled, superseded).
+     */
+    wakeAt?: number;
+    /** Set by the store on insert. */
+    createdAt?: number;
+    updatedAt: number;
+}
+/** What "Te bestellen" shows next to an end or a decrease: why it is on that day. */
+export interface TargetNotice {
+    /** The last day to send it for `effectiveAt`. */
+    deadline?: number;
+    /** The notice came too late for this term: it ends at the next one. */
+    nextTerm?: boolean;
+    /** We pay on after the customer stopped, until then. */
+    runsOnUntil?: number;
+    /** A decrease outside the change window: at the term's end, not now. */
+    atRenewal?: boolean;
+}
+export type RequestState = "draft" | "scheduled" | "queued" | "waiting" | "pending" | "unknown" | "inquiring" | "approved" | "failed" | "superseded";
+/** Not yet out the door: may still be replaced when the target moves (§3). */
+export declare const UNSENT_STATES: readonly RequestState[];
+/** Out the door and not settled: one per item at a time. */
+export declare const OPEN_STATES: readonly RequestState[];
+export type SentCommand = ProvisioningCommand & {
+    at: number;
+    /** The provider's per-attempt id where it documents one (Microsoft MS-RequestId). */
+    attemptRef?: string;
+};
+/** Goods still to deliver for one sales order line, or a restock (§2.4). */
+export interface FulfilmentOrder {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    source: {
+        kind: "order_line";
+        orderId: string;
+        lineId: string;
+    } | {
+        kind: "restock";
+        key: string;
+    };
+    customerCompanyId?: string;
+    productId: string;
+    /** Base units. */
+    quantity: number;
+    deliverTo: DeliverTo;
+    /** The offer it is bought on: a person's pick before the order, else what it was placed on. */
+    offerId?: string;
+    /** Who picked `offerId` by hand (045 B-3); absent = the server's choice. */
+    offerPickedBy?: string;
+    state: "open" | "closed" | "cancelled";
+    updatedAt: number;
+}
+/** Which part of which PO line or stock is meant for a fulfilment order. */
+export interface Allocation {
+    id: string;
+    organizationId: string;
+    fulfilmentOrderId: string;
+    supply: {
+        kind: "po_line";
+        orderId: string;
+        lineId: string;
+    } | {
+        kind: "stock";
+        locationId?: string;
+    };
+    /** Base units. */
+    quantity: number;
+    state: "active" | "released";
+    /** The order a partial receipt is shared in (FIFO, §4). */
+    createdAt: number;
+}
+/** A physical delivery, out or back. */
+export interface Delivery {
+    id: string;
+    organizationId: string;
+    fulfilmentOrderId: string;
+    allocationId?: string;
+    kind: "shipment" | "dropship";
+    direction?: "out" | "return";
+    /** Base units. */
+    quantity: number;
+    at: number;
+    evidence: {
+        receiptId?: string;
+        by?: string;
+    };
+    serials?: string[];
+    batches?: {
+        code: string;
+        quantity: number;
+        expiresAt?: number;
+    }[];
+    shipmentRef?: string;
+    carrier?: string;
+    trackingNumber?: string;
+}
+/**
+ * Deliverable here, before the promise (047 step 8, TMF679): the answers asked for one article,
+ * what each provider said (`perOffer`, with cost: internal) and that answer in our own assortment
+ * (`products`: the only part a customer may see). No address field: `site` is a crm address id.
+ */
+export interface Qualification {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    productId: string;
+    params: Record<string, string>;
+    perOffer: OfferQualification[];
+    products: QualifiedProduct[];
+    expiresAt: number;
+    createdBy: string;
+    at: number;
+}
+export type OfferQualification = ProviderQualification & {
+    app: string;
+    offer: string;
+};
+export interface QualifiedProduct {
+    productId: string;
+    available: boolean;
+    /** A code, never the supplier's words: `unavailable` or `no_answer`. */
+    reason?: "unavailable" | "no_answer";
+}
+/** What leaves fulfilment for a person or a portal: never the suppliers, networks or costs. */
+export type QualificationView = Omit<Qualification, "perOffer">;
+export declare const qualificationView: ({ perOffer: _, ...view }: Qualification) => QualificationView;

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

@@ -1,5 +1,7 @@
 import { BookingDocument } from '../../platform/bookkeeping';
-import { FiscalPeriod, JournalEntry, JournalKind, JournalLineData, LedgerAccount, PostingRule, TaxAccountMapping } from './types';
+import { LedgerMappingRule } from '../bookkeeping/types';
+import { TaxCode } from '../money/tax';
+import { FiscalPeriod, JournalEntry, JournalKind, JournalLineData, LedgerAccount } from './types';
 export type EntryProblem = {
     code: "entry_unbalanced";
     params: {
@@ -32,6 +34,21 @@ export type EntryProblem = {
     params: {
         day: string;
     };
+} | {
+    code: "entry_tax_side";
+    params: {
+        account: string;
+    };
+} | {
+    code: "fx_rate_required";
+    params: {
+        currency: string;
+    };
+} | {
+    code: "fx_cross_rate_unsupported";
+    params: {
+        currency: string;
+    };
 };
 /** Everything that stops an entry, checked in memory before the insert (plan 039 §4.4 step 1). */
 export declare function entryProblems(entry: {
@@ -40,28 +57,41 @@ export declare function entryProblems(entry: {
 }, context: {
     accounts: readonly LedgerAccount[];
     period?: Pick<FiscalPeriod, "status">;
-    /**
-     * `closed`: into a closed period too (the accountant, later). `locked`: into any, for the
-     * year end only — its lines carry no VAT, so a period locked by a VAT return stays true.
-     */
-    allow?: "closed" | "locked";
+    /** `closed`: into a closed period too (the year end, the accountant later). Never locked. */
+    allow?: "closed";
+    /** The administration's own currency; `EUR` when unset. */
+    functionalCurrency?: string;
 }): EntryProblem[];
 /** `"MEM-2026-0042"`. A split year numbers under the year it starts in. */
 export declare function entryNumber(journalCode: string, fiscalYear: string, seq: number): string;
 /** The fields the hash covers: everything that says what was booked, where, by whom, after what. */
 export type HashedEntry = Omit<JournalEntry, "id" | "organizationId" | "hash" | "createdAt">;
+/**
+ * Numbers through `Number()`: a store that returns INT8 as a string (Mervyn) must hash the same.
+ * Lines are taken as stored, so an entry from before a field existed keeps its hash.
+ */
 export declare function hashedPartOf(entry: JournalEntry | HashedEntry): HashedEntry;
 /**
  * Canonical JSON: keys sorted at every depth, `undefined` dropped. The same entry always gives the
  * same string, so a re-computed hash only differs when something was changed.
  */
 export declare function canonicalJson(value: unknown): string;
-/** A reversal: the same lines, every amount the other way. */
+/**
+ * The side a line's VAT counts on. A line booked before `taxSide` existed is guessed from its
+ * account, as the return used to: a revenue account is a sale, anything else a purchase.
+ */
+export declare function taxSideOf(line: Pick<JournalLineData, "taxSide">, account: Pick<LedgerAccount, "type"> | undefined): "sales" | "purchase";
+/**
+ * A reversal: the same lines, every amount the other way. The tax point stays; the return it
+ * counts in follows from `JournalLine.vatDate` (the next open one when that one was filed).
+ */
 export declare function reversedLines(lines: readonly JournalLineData[]): JournalLineData[];
 export interface DocumentPostingContext {
     accounts: readonly LedgerAccount[];
-    rules: readonly PostingRule[];
-    taxAccounts: readonly TaxAccountMapping[];
+    /** `BookkeepingBinding.ledgerMapping`: the only rules there are. The account id in our books. */
+    ledgerMapping?: readonly LedgerMappingRule[];
+    /** For `deductiblePercent`: the part of input VAT not deductible is cost, not VAT to reclaim. */
+    taxCodes?: readonly TaxCode[];
     /** The administration's own currency; `EUR` when unset. */
     functionalCurrency?: string;
 }
@@ -74,6 +104,14 @@ export type DocumentEntry = {
     ok: false;
     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

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

@@ -1,5 +1,6 @@
 import { BookingDocument } from '../../platform/bookkeeping';
 import { Cents } from '../money/money';
+import { LineDimensions } from '../transaction/types';
 /**
  * Our own books (plan 039 datamodel §4). One row per posting with its lines as a column, a hash
  * chain and gapless numbers guarded by unique indexes, and a line table that is only ever derived.
@@ -36,8 +37,14 @@ export interface LedgerAccount {
 }
 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";
+ | "fx_difference"
+/** What a filed VAT return moves 1500/1510 to: the amount owed to (or due from) the authority. */
+ | "vat_settlement"
+/** The cents a VAT return drops by rounding to whole euros. */
+ | "vat_rounding";
 export type JournalKind = "sales" | "purchase" | "bank" | "cash" | "memorial" | "opening";
+/** Where a person may post by hand (Exact type 90/10): a bank journal moves only with its lines. */
+export declare const MANUAL_JOURNAL_KINDS: readonly JournalKind[];
 export interface Journal {
     id: string;
     organizationId: string;
@@ -60,7 +67,10 @@ export interface FiscalPeriod {
     index: number;
     from: string;
     to: string;
-    /** open: post freely. closed: accountant only. locked: nobody (after a VAT return or year end). */
+    /**
+     * open: post freely. closed: accountant only. locked: nobody, after the year end. A VAT return
+     * locks nothing: a late line counts in the next return through `JournalLine.vatDate`.
+     */
     status: "open" | "closed" | "locked";
 }
 /**
@@ -82,23 +92,28 @@ export interface YearEnd {
     closedAt: number;
     closedBy: string;
 }
-/** A line as it sits in `JournalEntry.lines`. Debit positive, credit negative; the sum is zero. */
-export interface JournalLineData {
+/**
+ * A line as it sits in `JournalEntry.lines`. Debit positive, credit negative; the sum is zero.
+ * Hashed: this shape is frozen from the first production entry. The B1 dimensions are columns.
+ */
+export interface JournalLineData extends LineDimensions {
     accountId: string;
     amountCents: Cents;
     currency: string;
+    /**
+     * Functional = foreign × rate, as a decimal string. Set on every line of a converted document;
+     * absent when the document is in the administration's own currency (absent means 1).
+     */
     fxRate?: string;
     functionalCents: Cents;
     /** `TaxCode.key`, the VAT of this line, and when it counts. */
     taxCode?: string;
+    /** Which side of the return the code counts on: set with `taxCode`, never one without the other. */
+    taxSide?: "sales" | "purchase";
     taxCents?: Cents;
     taxPointDate?: string;
     subAccountId?: string;
-    costCenter?: string;
-    /** A work project as cost carrier. */
-    projectId?: string;
     counterpartyCompanyId?: string;
-    dimensions?: Record<string, string>;
     description?: string;
 }
 export interface JournalEntry {
@@ -130,6 +145,11 @@ export interface JournalEntry {
         dueOn?: string;
     };
     lines: JournalLineData[];
+    /**
+     * The party of a posted document as it went out (review R2): the EC sales list and the audit
+     * file read names and VAT numbers here, never crm. Hashed; absent on a manual entry.
+     */
+    counterparty?: BookingDocument["counterparty"];
     /** The entry this one reverses. The reversed entry itself is never changed. */
     reversesEntryId?: string;
     attachment?: {
@@ -155,31 +175,9 @@ export interface JournalLine extends JournalLineData {
     date: string;
     periodId: string;
     journalId: string;
-}
-/** How a `BookingDocument` becomes an entry. First match wins, in the order of the mapping. */
-export interface PostingRule {
-    id: string;
-    organizationId: string;
-    businessEntityId: string;
-    appliesTo: {
-        direction: BookingDocument["direction"];
-        kind?: BookingDocument["kind"];
-    };
-    match: {
-        productId?: string;
-        ledgerCategoryKey?: string;
-        taxRateKey?: string;
-    };
-    /** Revenue or expense account for the net line. */
-    accountId: string;
-    order: number;
-}
-/** Which account the VAT of a key lands on. Missing = the account with the VAT role. */
-export interface TaxAccountMapping {
-    id: string;
-    organizationId: string;
-    businessEntityId: string;
-    taxKey: string;
-    payableAccountId?: string;
-    receivableAccountId?: string;
+    /**
+     * The day the VAT return counts this line on (lines with a `taxCode` only): its tax point, or
+     * the day after the last return filed before it was posted. Derived, outside the hash.
+     */
+    vatDate?: string;
 }

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

@@ -31,7 +31,10 @@ export interface XafInput {
         };
     };
     relations: {
+        /** The company id: what a transaction line's `counterpartyCompanyId` points at. */
         id: string;
+        /** Its debtor or creditor number at this administration: the `custSupID` when given. */
+        number?: string;
         name: string;
         commerceNr?: string;
         vatNumber?: string;