@opencxh/domain 1.302.0 → 1.304.0

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

@@ -52,6 +52,11 @@ 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[];
+/**
+ * Where the schedule starts over: a revision, or else an opening taken over (the month after
+ * `on`, from the book value then, numbered on from the months already done).
+ */
+export declare function restartOf(t: FixedAssetTerms): FixedAssetTerms["restart"];
 /**
  * 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
@@ -60,7 +65,7 @@ export declare function spread(totalCents: Cents, months: number): Cents[];
  */
 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"> & {
+export declare function depreciationPostings(item: Pick<FinancingItem, "id" | "name" | "counterpartyCompanyId" | "dimensions"> & {
     terms: FixedAssetTerms;
 }, through: string): PlannedPosting[];
 /**
@@ -78,12 +83,13 @@ export declare function disposalLines(item: Pick<FinancingItem, "id" | "name" |
     disposalAccountId: string;
 }): PlannedPosting["lines"];
 /** A transitorium released month by month onto its result account. */
-export declare function accrualPostings(item: Pick<FinancingItem, "id" | "name" | "ledgerAccountId"> & {
+export declare function accrualPostings(item: Pick<FinancingItem, "id" | "name" | "ledgerAccountId" | "counterpartyCompanyId" | "dimensions"> & {
     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).
+ * on the item plus what its terms say was there to begin with (cost less a taken-over
+ * accumulated depreciation, or an amount paid upfront).
  */
 export declare function startingCents(terms: FixedAssetTerms | AccrualTerms): Cents;
 /**

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

@@ -1,4 +1,6 @@
+import { JournalLineData } from '../ledger/types';
 import { Cents } from '../money/money';
+import { LineDimensions } from '../transaction/types';
 /**
  * Balance items with detail under a ledger account (plan 039 §3.6b, datamodel §5): loans, the
  * director's current account, participations and deposits. One row per item; `kind` says which
@@ -88,6 +90,16 @@ export interface FixedAssetTerms {
         bookValueCents: Cents;
         fromSequence: number;
     };
+    /**
+     * Taken over with depreciation already booked elsewhere (Exact `AlreadyDepreciated`): the
+     * schedule starts the month after `on`, numbered on from `monthsDone`, over the book value left.
+     * The accumulated amount sits in the opening balance, not on the item's sub-account.
+     */
+    opening?: {
+        on: string;
+        accumulatedCents: Cents;
+        monthsDone: 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.
@@ -190,6 +202,8 @@ export interface FinancingItem {
     /** The other party: a crm company (bank, participation, landlord) or a person by name (the director). */
     counterpartyCompanyId?: string;
     counterpartyName?: string;
+    /** From the line it was made of: its releases and depreciation carry them, as its lines did. */
+    dimensions?: LineDimensions;
     currency: string;
     terms: FinancingTerms;
     openedOn?: string;
@@ -200,6 +214,8 @@ export interface FinancingItem {
     createdAt?: number;
     updatedAt?: number;
 }
+/** A journal line before the run fills its currency and functional amount. */
+export type PlannedLine = Omit<JournalLineData, "currency" | "functionalCents" | "fxRate">;
 /**
  * A prepared posting from an item's schedule (datamodel §5.2): an instalment, a quarter's
  * interest. One per (item, sequence), so a repeated run makes no twin.
@@ -215,12 +231,7 @@ export interface ScheduledPosting {
      * The lines as they become an entry. For `bank_line` these are the non-bank side only: the bank
      * line that pays it adds its own side. Their sum is what the bank line must be, signed.
      */
-    lines: {
-        accountId: string;
-        amountCents: Cents;
-        subAccountId?: string;
-        description?: string;
-    }[];
+    lines: PlannedLine[];
     /** What the bank line should show: − for an instalment paid, + for one received. */
     expectedBankCents: Cents;
     /** planned: in the future · due: today or earlier · posted · skipped (by a person, with a reason). */

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

@@ -0,0 +1,149 @@
+import { ProvidedResource, ProviderAccount, ProvisionableOffer, ReportedSubscription } from '../../platform/provisioning';
+import { SupplierOffer } from '../purchase/types';
+import { StructureProblem } from './rules';
+import { ProvisionedItem } from './types';
+/**
+ * One thing that already runs, as a source gives it (047 step 9): a provider's list, a file, and
+ * later another PSA — every source yields these rows, and one flow takes them over.
+ */
+export interface AdoptRow {
+    /** The platform it runs on: the provider app, or what a file names (`3cx`). */
+    app: string;
+    externalRef: string;
+    /** The provider's offer key, or the supplier's article number (a file). */
+    offer: string;
+    level: "account" | "item";
+    quantity: number;
+    /** Who it runs for, as the supplier names them: matched to a crm company. */
+    account: {
+        ref: string;
+        name: string;
+        kvkNumber?: string;
+        domain?: string;
+    };
+    /** Already known: the account it runs under is ours, so is its customer. */
+    customerCompanyId?: string;
+    /** The account it runs under at the same app (an Eylo account): that account's `externalRef`. */
+    under?: string;
+    uses?: ProvidedResource[];
+    /** The original start at the supplier: kept on the item, never billed from (vraag 6). */
+    since?: number;
+    termEndsAt?: number;
+    status?: ReportedSubscription["status"];
+    fulfillment?: Record<string, string>;
+    /** What the provider listed, whole: becomes `reported`. */
+    reported?: ReportedSubscription;
+}
+export interface CustomerCandidate {
+    id: string;
+    name: string;
+}
+/** A customer's agreements as sales lists them for linking (`/provider/agreement/for-customer`). */
+export interface AdoptAgreement {
+    id: string;
+    status: string;
+    lines: {
+        seriesId: string;
+        productId: string;
+    }[];
+}
+export interface AdoptContext {
+    organizationId: string;
+    businessEntityId: string;
+    now: number;
+    offers: readonly SupplierOffer[];
+    described: ReadonlyMap<string, ProvisionableOffer>;
+    /** crm's candidates per account key (`<app>:<account ref>`). */
+    customers: ReadonlyMap<string, readonly CustomerCandidate[]>;
+    /** A person's pick per account key, where crm had more than one. */
+    chosen?: Readonly<Record<string, string>>;
+    /** Live items the rows may be, run under, use, or link to. */
+    items: readonly ProvisionedItem[];
+    agreements: ReadonlyMap<string, readonly AdoptAgreement[]>;
+    /** The draft lines sales made for rows, by row key (commit, second pass). */
+    drafted?: ReadonlyMap<string, {
+        agreementId: string;
+        seriesId: string;
+    }>;
+}
+export type AdoptProblem = StructureProblem
+/** Numbers, devices: one item per unit (D5). */
+ | {
+    code: "one_unit_per_item";
+    quantity: number;
+}
+/** What its offer needs to run (an account) is in neither the import nor the register. */
+ | {
+    code: "requires_missing";
+    role: string;
+};
+export type AdoptState = "known" | "ready" | "choose_customer" | "no_product" | "ended" | "blocked";
+/** What one row becomes. Nothing is written: {@link adoptPlan} is the preview and the commit's plan. */
+export interface AdoptLine {
+    key: string;
+    row: AdoptRow;
+    state: AdoptState;
+    knownItemId?: string;
+    customer?: {
+        companyId?: string;
+        create: boolean;
+        candidates: readonly CustomerCandidate[];
+    };
+    offerId?: string;
+    productId?: string;
+    /** A running series it joins, or a line on the customer's draft agreement; absent = a resource. */
+    sale?: {
+        agreementId: string;
+        seriesId: string;
+    } | {
+        draft: true;
+    };
+    item?: ProvisionedItem;
+    problems: AdoptProblem[];
+}
+/** The series id of a draft line made for a row: one per supplier identity, so a repeat finds it. */
+export declare const adoptSeriesId: (key: string) => string;
+export declare const isAdoptSeries: (seriesId: string) => boolean;
+/**
+ * What taking these rows over makes, per row (047 step 9): which customer (crm's one candidate, a
+ * person's pick, else a new company), which article (the offer at the supplier), which agreement
+ * (a free running series of that article, else a line on the customer's draft), and the item —
+ * `active`, its key at the supplier, what it runs under and uses. A key a live item already holds
+ * is "known"; a structure that does not hold is "blocked" with its problems. Pure: no store, no call.
+ */
+export declare function adoptPlan(rows: readonly AdoptRow[], ctx: AdoptContext): AdoptLine[];
+/** The preview's head count: what comes, what is already there, what still needs a person. */
+export declare function adoptSummary(lines: readonly AdoptLine[]): {
+    items: number;
+    draftLines: number;
+    linked: number;
+    contractLines: number;
+    newCustomers: number;
+    known: number;
+    choose: number;
+    noProduct: number;
+    blocked: number;
+};
+/** A provider's account as a row: the account itself is taken over too (an Eylo account, a tenant). */
+export declare const accountRow: (app: string, account: ProviderAccount) => AdoptRow;
+/** One listed subscription under an account, as a row. */
+export declare const subscriptionRow: (app: string, account: AdoptRow["account"], subscription: ReportedSubscription, customerCompanyId?: string) => AdoptRow;
+/** The columns a file can hold (047 step 9): customer, article, count, reference, dates. */
+export declare const ADOPT_COLUMNS: readonly ["customer", "product", "quantity", "externalRef", "since", "termEndsAt", "kvkNumber", "domain", "under"];
+export type AdoptColumn = (typeof ADOPT_COLUMNS)[number];
+export type AdoptMapping = Partial<Record<AdoptColumn, string>>;
+/** A first mapping from the header: exact words first, then a header that starts with one. */
+export declare function guessAdoptMapping(header: readonly string[]): AdoptMapping;
+/** `2026-03-01`, `1-3-2026` or `01/03/2026` as UTC midnight; anything else is `undefined`. */
+export declare function parseDay(text: string): number | undefined;
+/**
+ * A file's cells as rows, through the mapping. A line without a customer, article or reference,
+ * or with a count or date that does not read, is an error with its line number — never a guess.
+ */
+export declare function adoptRowsFromTable(table: readonly string[][], mapping: AdoptMapping, app: string): {
+    rows: AdoptRow[];
+    errors: {
+        line: number;
+        message: string;
+    }[];
+};

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

@@ -0,0 +1,99 @@
+import { AnswerSpec, OfferRef, Preparation, ProvisioningAnswers, Requirement, RequirementGate } from '../../platform/provisioning';
+import { Commitment, LineRhythm } from '../agreement/types';
+/**
+ * One article configured for one customer (plan 053): the answers, the offer chosen and what the
+ * provider last said. Sales carries only its id; fulfilment freezes the answers into the request.
+ */
+export interface Configuration {
+    id: string;
+    organizationId: string;
+    businessEntityId: string;
+    customerCompanyId: string;
+    productId: string;
+    /** The offer it is bought through; its `sku` follows the `main` answer. */
+    ref?: OfferRef;
+    supplierOfferId?: string;
+    answers: ProvisioningAnswers;
+    preparation?: Preparation;
+    preparedAt?: number;
+    createdBy: string;
+    updatedAt: number;
+}
+export type ConfigurationStatus = "open" | "ready" | "expired";
+/** "Via leverancier" (plan 053): a provider whose flow asks something, and what it starts with. */
+export interface SupplierFlow {
+    app: string;
+    label: string;
+    asks: AnswerSpec[];
+    productIds: string[];
+}
+/** Step 1, one article on the answers so far: can it be delivered, and from what cost. */
+export interface ArticleCheck {
+    productId: string;
+    supplierOfferId: string;
+    available: boolean;
+    /** The first unmet condition's reason; absent when only questions are left. */
+    reason?: string;
+    /** The cheapest main option, per month where it recurs. Internal: colleagues only. */
+    fromCents?: number;
+    labels: string[];
+}
+/** One line a configuration sells, with the upsell article it becomes — or none yet. */
+export interface ConfiguredSale {
+    /** The answer it comes from; absent for the main line. */
+    optionKey?: string;
+    label: string;
+    sku: string;
+    quantity: number;
+    costCents?: number;
+    recurring?: "month";
+    /** Our article: the configured one for the main line, the upsell rule's for a sub-line. */
+    productId?: string;
+    commitment?: Partial<Commitment>;
+}
+export interface ConfigurationView {
+    configuration: Configuration;
+    status: ConfigurationStatus;
+    sales: ConfiguredSale[];
+}
+/** What still stands in the way of `gate`: at `order`, the quote's requirements count too. */
+export declare function blockersOf(preparation: Preparation, gate: RequirementGate): Requirement[];
+/** Ready for `gate` when prepared, not expired and nothing blocks it. */
+export declare function configurationStatus(config: Pick<Configuration, "preparation">, gate: RequirementGate, now: number): ConfigurationStatus;
+/** A chosen product: the main line's or one add-on's. Cost is per unit, internal. */
+export interface ConfiguredLine {
+    /** The answer it comes from (`evc_2`, `sla`). */
+    key: string;
+    /** As the provider names it: what an upsell article's match reads. */
+    label: string;
+    sku: string;
+    quantity: number;
+    costCents?: number;
+    recurring?: "month";
+    commitment?: Partial<Commitment>;
+    billedEvery?: LineRhythm;
+}
+/**
+ * What the answers buy: the supplier's product for the main line, and one sub-line per add-on
+ * taken (decided 05-10: an add-on is its own sales line). A `no` or a `0` is no line.
+ */
+export declare function linesOf(preparation: Preparation, answers: ProvisioningAnswers): {
+    main?: ConfiguredLine;
+    addons: ConfiguredLine[];
+};
+/** The offer as bought: the chosen main product becomes its sku, its option's commitment ours. */
+export declare function chosenOf(ref: OfferRef, preparation: Preparation, answers: ProvisioningAnswers): {
+    ref: OfferRef;
+    commitment?: Partial<Commitment>;
+    billedEvery?: LineRhythm;
+};
+/**
+ * The answers that go out, frozen on the request: only keys the provider asked for, its own
+ * proposal where nobody typed one. A stray key never reaches the supplier.
+ */
+export declare function orderAnswers(preparation: Preparation, answers: ProvisioningAnswers): ProvisioningAnswers;
+/**
+ * An exclusive item configured per unit (plan 053 G2: ten SIMs, ten numbers to port): one set of
+ * answers per unit, the shared ones copied, the `perUnit` ones from `perUnitValues` in order.
+ */
+export declare function splitUnits(preparation: Preparation, answers: ProvisioningAnswers, quantity: number, perUnitValues?: Record<string, string[]>): ProvisioningAnswers[];

package/dist/entities/fulfilment/configuration.test.d.ts

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

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

@@ -0,0 +1,63 @@
+import { supplyChain } from './rules';
+import { ProvisionedItem, ProvisioningRequest } from './types';
+/** Where the five columns disagree, and what a person can do about it (047 step 5). */
+export type ProductSignal = 
+/** The supplier runs another count than we think: "overnemen" or "terugzetten". */
+{
+    kind: "supplier_differs";
+    reported: number;
+    active: number;
+}
+/** What runs is not what was agreed; `busy` = a request is already on it. */
+ | {
+    kind: "agreed_differs";
+    agreed: number;
+    active: number;
+    busy: boolean;
+}
+/** We pay for another count than runs. */
+ | {
+    kind: "not_bought";
+    bought: number;
+    active: number;
+}
+/** The last period billed another count than agreed. */
+ | {
+    kind: "not_billed";
+    billed: number;
+    agreed: number;
+};
+export interface CustomerProductRow {
+    itemId: string;
+    productId: string;
+    customerCompanyId: string;
+    status: ProvisionedItem["status"];
+    serial?: string;
+    /** Afgesproken: the agreement's count now; `null` when it is not a fixed count (or an order). */
+    agreed: number | null;
+    /** Actief: what we know runs. */
+    active: number;
+    /** Bij de leverancier: what the supplier reports, when it reports. */
+    reported?: number;
+    /** Ingekocht: the contract line's count. */
+    bought?: number;
+    /** Gefactureerd: the last period's count. */
+    billed?: number;
+    signals: ProductSignal[];
+    /** What it rests on ("Technische resources"), once each, with its product and whether shared. */
+    resources: (ReturnType<typeof supplyChain>[number] & {
+        productId: string;
+    })[];
+}
+/**
+ * "Producten bij klanten": every item a customer takes, its five counts side by side, and a signal
+ * where two disagree (047 step 5). Compared per item and per product, never summed over roles
+ * (§10.4): one account and ten licences are not eleven bought.
+ */
+export declare function customerProducts(input: {
+    items: readonly ProvisionedItem[];
+    requests: readonly ProvisioningRequest[];
+    agreed: ReadonlyMap<string, number | null>;
+    billed: ReadonlyMap<string, number>;
+    bought: ReadonlyMap<string, number>;
+}): CustomerProductRow[];

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

@@ -0,0 +1,67 @@
+import { ProvisionableOffer, ProvisioningAction, ProvisioningResult, ReportedSubscription, RoleNeed } from '../../platform/provisioning';
+import { NotReady } from './rules';
+import { ProvisionedItem, ProvisioningRequest, ReportedState, RequestState, SentCommand } from './types';
+/** Released by a person, not yet out: the engine moves these on its own (§2.2). */
+export declare const RELEASED_STATES: readonly RequestState[];
+export declare const nextAttemptAt: (attempts: number, now: number) => number;
+export type Admission = {
+    state: "scheduled";
+} | {
+    state: "queued" | "waiting";
+    why: NotReady;
+} | {
+    state: "send";
+    inputs: NonNullable<ProvisioningRequest["inputs"]>;
+};
+/**
+ * Where a released request goes now: `scheduled` until its `submitAt`, `queued` behind another
+ * open request on its item, `waiting` for what comes first or for a role (§10.1), else out.
+ */
+export declare function admit(input: {
+    request: ProvisioningRequest;
+    item: ProvisionedItem;
+    needs: readonly RoleNeed[];
+    items: ReadonlyMap<string, ProvisionedItem>;
+    requests: readonly ProvisioningRequest[];
+    now: number;
+}): Admission;
+/**
+ * What goes out, frozen (§2.2): a retry sends exactly this. The account the item runs under goes
+ * as `parent` for every act — a cancel needs to know where, even when it demands nothing active.
+ */
+export declare function commandOf(input: {
+    request: ProvisioningRequest;
+    item: ProvisionedItem;
+    inputs: NonNullable<ProvisioningRequest["inputs"]>;
+    items: ReadonlyMap<string, ProvisionedItem>;
+    now: number;
+}): SentCommand;
+export type Recovery = "resend" | "status" | "listing" | "person";
+/**
+ * How an `unknown` outcome is found out, per act, as the provider declares (§2.3). Undeclared is
+ * a person: guessing could buy twice. A `lookup_by_listing` purchase is never sent again.
+ */
+export declare function recoveryOf(action: ProvisioningAction, offer?: ProvisionableOffer): Recovery;
+/**
+ * What an approved request does to its item (§2.1): a purchase makes it active (the first time
+ * sets `activatedAt`, §10.2), a partial success counts what succeeded, a cancel ends it — on its
+ * day, `terminating` until then. Anything but `approved` leaves the item as it is.
+ */
+export declare function settle(item: ProvisionedItem, request: ProvisioningRequest, result: ProvisioningResult, now: number): Partial<ProvisionedItem>;
+/**
+ * A purchase whose answer was lost, looked for in what the supplier lists (`lookup_by_listing`,
+ * §2.3): by our reference where it keeps one, else the one subscription of that offer and count
+ * that no item knows. Two candidates, or none yet: a person decides — never a second purchase.
+ */
+export declare function findInListing(request: Pick<ProvisioningRequest, "requestId" | "offer" | "quantity" | "sent">, listed: readonly ReportedSubscription[], knownRefs: ReadonlySet<string>): {
+    state: "found";
+    subscription: ReportedSubscription;
+} | {
+    state: "none";
+} | {
+    state: "ambiguous";
+    count: number;
+    candidates: ReportedSubscription[];
+};
+/** What the supplier says about one item, as `reported` keeps it. */
+export declare function reportOf(subscription: ReportedSubscription, now: number): ReportedState;

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

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

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

@@ -0,0 +1,72 @@
+import { TransactionDraft } from '../transaction/convert';
+import { SalesTransaction } from '../transaction/types';
+import { Allocation, Delivery, FulfilmentOrder } from './types';
+/**
+ * A partial receipt shared over the allocations on one PO line, oldest first (§4): 6 of 10 in,
+ * with A holding 6 and B 4, gives A its 6 and B nothing yet. Per allocation what arrived for it,
+ * and what of that can still go out: `min(allocated, received share) − delivered`.
+ */
+export declare function shareReceipts(allocations: readonly Allocation[], received: number, delivered: ReadonlyMap<string, number>): Map<string, {
+    received: number;
+    available: number;
+}>;
+/** The counts of one fulfilment order (§5), in base units. */
+export interface GoodsTallies {
+    ordered: number;
+    allocated: number;
+    onOrder: number;
+    available: number;
+    delivered: number;
+    returned: number;
+}
+export declare function tallies(order: Pick<FulfilmentOrder, "id" | "quantity">, allocations: readonly Allocation[], deliveries: readonly Delivery[], share: ReadonlyMap<string, {
+    received: number;
+    available: number;
+}>): GoodsTallies;
+/**
+ * Whether two fulfilment orders may share one PO line (§4): the same offer (so the same supplier,
+ * product, administration and currency), the same administration on our side, and the same
+ * destination. A drop shipment to two customers is never one line.
+ */
+export declare const mergeable: (a: Pick<FulfilmentOrder, "offerId" | "businessEntityId" | "deliverTo">, b: Pick<FulfilmentOrder, "offerId" | "businessEntityId" | "deliverTo">) => boolean;
+/** One order line: what was ordered, delivered, invoiced, and what a draft holds (§5). */
+export interface LineProgress {
+    lineId: string;
+    ordered: number;
+    delivered: number;
+    /** Net of credit notes, issued documents only. */
+    invoiced: number;
+    /** On a draft invoice: counted as invoiced, so two partial runs never bill it twice. */
+    reserved: number;
+}
+/**
+ * Per line of `order`, from the deliveries (by order line) and every invoice and credit note that
+ * points back. A credit note points at its invoice line, so the chain is followed to the order
+ * line it came from (Codex 8). Quantities in the line's own unit; a credit counts negative.
+ */
+export declare function orderProgress(order: Pick<SalesTransaction, "id" | "lines">, delivered: ReadonlyMap<string, number>, documents: readonly Pick<SalesTransaction, "id" | "kindKey" | "status" | "issuedAt" | "lines">[]): LineProgress[];
+/** What is still to invoice on a line: delivered (or ordered) minus invoiced and reserved. */
+export declare const toInvoice: (row: LineProgress, mode: "delivered" | "ordered") => number;
+/** none · partial · full, per axis — what the order list shows next to its status. */
+export declare function progressState(rows: readonly LineProgress[], axis: "delivered" | "invoiced"): "none" | "partial" | "full";
+type Billable = Pick<SalesTransaction, "id" | "kindKey" | "status" | "issuedAt" | "lines" | "companyId" | "businessEntityId" | "currency">;
+/**
+ * Invoices from orders (047 step 4, §5): per product line what is still to invoice — delivered
+ * (or ordered) minus invoiced and what draft invoices already hold — each line pointing back at
+ * its order line. `order`: one invoice per order; `customer`: one per customer and debtor, billing
+ * address, payment term, VAT treatment, administration and currency, whose lines each point at
+ * their own order. The delivery date is the last delivery in
+ * it (the VAT point), on delivered; else the order's. Nothing to invoice: no draft.
+ */
+export declare function invoicesFromOrders(input: {
+    orders: readonly SalesTransaction[];
+    /** Per order, delivered per order line in the line's own unit. */
+    delivered: ReadonlyMap<string, ReadonlyMap<string, number>>;
+    /** The last day something went out, per order. */
+    deliveredAt?: ReadonlyMap<string, number>;
+    /** Every invoice and credit note that may point back at these orders. */
+    documents: readonly Billable[];
+    mode: "delivered" | "ordered";
+    groupBy: "order" | "customer";
+}): TransactionDraft[];
+export {};

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

@@ -0,0 +1,9 @@
+export * from './adopt';
+export * from './configuration';
+export * from './customers';
+export * from './execute';
+export * from './goods';
+export * from './path';
+export * from './rules';
+export * from './target';
+export * from './types';

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

@@ -0,0 +1,8 @@
+/**
+ * A fulfilment id in a URL path. Ours hold `#` and `:` (`sale:a1#s1:purchase:3`) and a path cuts
+ * at `#`, so the id travels base64url-encoded; the page reads it back. Browser-only (`btoa`).
+ */
+export declare const toPathKey: (id: string) => string;
+export declare const fromPathKey: (key: string) => string;
+/** Where a request's page is, for an app that links to it (purchase's order lines). */
+export declare const requestPath: (id: string) => string;

package/dist/entities/fulfilment/path.test.d.ts

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