@opencxh/domain 1.302.0 → 1.303.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/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,8 @@
+export * from './adopt';
+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 {};

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

@@ -0,0 +1,124 @@
+import { ProvidedResource, ProvisioningAction, RoleNeed } from '../../platform/provisioning';
+import { ProvisionedItem, ProvisioningRequest } from './types';
+/** `<itemId>:<action>:<revision>`: stable over retries and repeated events, new per change. */
+export declare const requestIdOf: (itemId: string, action: ProvisioningAction, revision: string) => string;
+export type NotReady = {
+    reason: "after";
+    requestIds: string[];
+} | {
+    reason: "busy";
+    requestId: string;
+} | {
+    reason: "missing_role";
+    role: string;
+} | {
+    reason: "too_many";
+    role: string;
+} | {
+    reason: "not_active";
+    role: string;
+    itemId: string;
+} | {
+    reason: "wrong_kind";
+    role: string;
+    itemId: string;
+};
+/**
+ * Whether a request may go out now, and the inputs it carries (§10.1). Per act: only the roles
+ * whose `for` names this act must be bound and active — a cancel needs nothing active, so an Eylo
+ * link can be cleared after the Telnyx number already ended. Inputs are bound by role (the
+ * relation), then the kind is checked: two numbers may play different roles.
+ */
+export declare function ready(request: Pick<ProvisioningRequest, "id" | "itemId" | "action" | "after">, item: Pick<ProvisionedItem, "requires">, needs: readonly RoleNeed[], items: ReadonlyMap<string, ProvisionedItem>, requests: readonly Pick<ProvisioningRequest, "id" | "itemId" | "state">[]): {
+    ok: true;
+    inputs: NonNullable<ProvisioningRequest["inputs"]>;
+} | ({
+    ok: false;
+} & NotReady);
+/**
+ * The day sales billing starts, when an item's status moves (§10.2). Only `billingStart:
+ * activation`, only an item the customer takes (`sale`), and only the first activation: a resume
+ * after a suspension keeps the original start.
+ */
+export declare function billingStartOf(item: Pick<ProvisionedItem, "sale" | "activatedAt">, from: ProvisionedItem["status"], to: ProvisionedItem["status"], billingStart: "date" | "delivery" | "activation", at: number): number | undefined;
+/** The items still using `itemId`: anything not ended, pending included (§10.3). */
+export declare function usersOf(itemId: string, items: Iterable<ProvisionedItem>): ProvisionedItem[];
+/**
+ * Ending something, in the two directions of §10.3:
+ * - **down** (a customer service ends): the items it uses become a *draft* cancel, but only when
+ *   nothing else uses them afterwards and they are not to be kept;
+ * - **up** (a resource ends): the services that use it are the impact — never cancelled for you.
+ * Re-run before sending: a draft may be stale by then.
+ */
+export declare function cancelPlan(target: ProvisionedItem, items: ReadonlyMap<string, ProvisionedItem>): {
+    release: string[];
+    keep: {
+        itemId: string;
+        why: "kept" | "in_use";
+    }[];
+    impact: string[];
+};
+/**
+ * Whether a cancel on `item` may go now (§10.3, checked again at sending): not while anything
+ * still uses it, pending and ending included — the service that ends in November keeps its number
+ * until then. A proposal that came from ending what used it also respects "keep".
+ */
+export declare function endable(item: Pick<ProvisionedItem, "id" | "keep">, all: Iterable<ProvisionedItem>, proposed: boolean): {
+    ok: true;
+} | {
+    ok: false;
+    reason: "in_use";
+    users: string[];
+} | {
+    ok: false;
+    reason: "kept";
+};
+export type StructureProblem = {
+    code: "unknown_item";
+    itemId: string;
+} | {
+    code: "cycle";
+    path: string[];
+} | {
+    code: "wrong_kind";
+    role: string;
+    itemId: string;
+} | {
+    code: "duplicate_key";
+    externalKey: string;
+    itemId: string;
+} | {
+    code: "wrong_entity";
+    itemId: string;
+};
+/**
+ * What saving this item and its relations would break (§10.5, and adopting in step 9): a relation
+ * to nothing, a cycle, a resource of the wrong kind for its role, a supplier identity another live
+ * item already holds, a relation into another administration. Coverage (`min`/`max`) is not
+ * checked here — a draft may still miss a role; {@link ready} demands it before sending.
+ */
+export declare function structureProblems(item: Pick<ProvisionedItem, "id" | "requires" | "externalKey" | "businessEntityId">, needs: readonly RoleNeed[], items: ReadonlyMap<string, ProvisionedItem>): StructureProblem[];
+/**
+ * What a sold item rests on, for comparing sold and bought (§10.4): every item it uses, once
+ * (deduplicated by id), with whether it is shared with another sold item. A shared resource stays
+ * out of a cost per customer until there is an explicit allocation rule.
+ */
+export declare function supplyChain(sold: ProvisionedItem, items: ReadonlyMap<string, ProvisionedItem>): {
+    itemId: string;
+    role: string;
+    supplied: boolean;
+    shared: boolean;
+}[];
+/**
+ * Whether a decrease to `quantity` may happen now. Microsoft NCE gives every add-on its own
+ * window (`reported.refundable`); without that report the supplier has no window to respect.
+ * Outside it, the decrease waits for the term's end.
+ */
+export declare function canDecrease(item: Pick<ProvisionedItem, "quantity" | "reported">, quantity: number, at: number): {
+    now: true;
+} | {
+    now: false;
+    at?: number;
+};
+/** The first resource of `kind` an item provides. */
+export declare const providedOf: (item: Pick<ProvisionedItem, "provides">, kind: ProvidedResource["kind"]) => ProvidedResource | undefined;