@happyvertical/smrt-planner 0.0.2 → 0.1.1

package/dist/data/fakes.js

@@ -1,5 +1,6 @@
+import { getModelByQualifiedName } from "../catalog/index.js";
 import { isLineModel } from "./derived.js";
-import { GENERIC_PACK, getSamplePack, getSampleTaxRate, } from "./packs.js";
+import { GENERIC_PACK, getSamplePack, getSamplePricing, getSampleTaxRate, } from "./packs.js";
 /** Deterministic PRNG (mulberry32): the same seed always yields the same run. */
 export function createRandom(seed) {
     let state = seed >>> 0;
@@ -20,16 +21,26 @@ export function hashString(value) {
     }
     return hash >>> 0;
 }
-const MONEY_NAME = /(price|amount|cost|total|balance|fee|tax|revenue|budget|salary|wage|subtotal|discount|spend|payout|commission|credit|debit|charge|refund|fare|rent)/i;
-const NOT_MONEY_NAME = /(count|quantity|qty|percent|ratio|level)/i;
+// `...Minor` is smrt's name for an amount in minor units (`DocumentTax`'s
+// `taxableMinor`, `TaxSummaryReport`'s `ledgerMovementMinor`).
+const MONEY_NAME = /(price|amount|cost|total|balance|fee|tax|revenue|budget|salary|wage|subtotal|discount|spend|payout|commission|credit|debit|charge|refund|fare|rent|[a-z]Minor$)/i;
+// A count is not money; a dis-count is (`discountTotal`).
+const NOT_MONEY_NAME = /((?<!dis)count|quantity|qty|percent|ratio|level)/i;
 /**
- * Money is stored as integer minor units (cents). A field is money when it is
- * an integer whose name says so; everything else numeric is a plain number.
+ * Money is stored as integer minor units (cents). An integer field is money
+ * when the manifest says so (`ui.format === 'money'`); a field that declares
+ * any other format is not, and neither is a framework-managed one. With no
+ * declared format the field's name decides.
  */
 export function isMoneyField(field) {
-    return (field.type === 'integer' &&
-        MONEY_NAME.test(field.name) &&
-        !NOT_MONEY_NAME.test(field.name));
+    if (field.type !== 'integer')
+        return false;
+    const format = field.ui?.format;
+    if (format !== undefined)
+        return format === 'money';
+    if (field.system)
+        return false;
+    return MONEY_NAME.test(field.name) && !NOT_MONEY_NAME.test(field.name);
 }
 const WORDS = [
     'Harbor',
@@ -76,6 +87,8 @@ const SENTENCES = [
 ];
 /** Fixed clock so seeded timestamps never change between runs. */
 export const EPOCH = Date.UTC(2026, 0, 1);
+/** Sample rows per model unless a pack or {@link SAMPLE_ROW_COUNTS} says otherwise. */
+export const DEFAULT_SAMPLE_ROWS = 8;
 const YEAR = 365 * 24 * 60 * 60 * 1000;
 function pick(random, list) {
     return list[Math.floor(random() * list.length)];
@@ -110,6 +123,12 @@ const CHANNELS = ['web', 'retail', 'phone', 'marketplace', 'wholesale'];
 const PERIODS = ['monthly', 'quarterly', 'annual'];
 /** Fractions a tax rate takes: 0%, 5%, 8.25%, 13% and 20%. */
 export const TAX_RATES = [0, 0.05, 0.0825, 0.13, 0.2];
+/**
+ * The sample tax rate when neither the app's setting nor the pack names one:
+ * every line of every document is taxed at it, so a document's tax is one
+ * rate of its subtotal, as on a real invoice.
+ */
+export const DEFAULT_SAMPLE_TAX_RATE = 0.05;
 function fakeText(field, random, modelName = '') {
     const name = field.name.toLowerCase();
     if (/terms/.test(name))
@@ -158,7 +177,7 @@ function fakeText(field, random, modelName = '') {
         return pick(random, ['active', 'pending', 'archived', 'draft']);
     }
     if (/(currency)/.test(name))
-        return 'USD';
+        return getSamplePricing().currency;
     if (/(person|owner|author|contact|assignee|worker)/.test(name)) {
         return `${pick(random, FIRST)} ${pick(random, LAST)}`;
     }
@@ -175,7 +194,41 @@ export const SAMPLE_ROW_COUNTS = {
     '@happyvertical/smrt-profiles:Profile': 13,
     '@happyvertical/smrt-commerce:Vendor': 5,
 };
-/** Sample rows for a model: the pack's count, else the shared one, else `fallback`. */
+const CUSTOMER_MODEL = '@happyvertical/smrt-commerce:Customer';
+/**
+ * How many rows of each customer-linked model (orders, quotes, invoices,
+ * payments: any model with a FK to a Customer) point at each sample customer:
+ * 3 to 6, uneven, seeded by the customer's index so it never changes. The
+ * slots interleave (every customer once, then again...), so a list's first
+ * rows still show different customers and row `n < customers` points at
+ * customer `n`.
+ */
+export function customerSlots(customers) {
+    const cached = slotCache.get(customers);
+    if (cached)
+        return cached;
+    const counts = Array.from({ length: customers }, (_, k) => 3 + (hashString(`customer-rows:${k}`) % 4));
+    const slots = [];
+    for (let round = 0; round < 6; round++) {
+        counts.forEach((count, k) => {
+            if (count > round)
+                slots.push(k);
+        });
+    }
+    slotCache.set(customers, slots);
+    return slots;
+}
+const slotCache = new Map();
+/** Does the model's rows belong to a customer (a FK to Customer, not its Profile)? */
+function isCustomerLinked(modelId) {
+    const model = getModelByQualifiedName(modelId)?.model;
+    return (model?.fields.some((f) => (f.type === 'foreignKey' || f.type === 'crossPackageRef') &&
+        f.related === CUSTOMER_MODEL) ?? false);
+}
+/**
+ * Sample rows for a model: the pack's count, else the shared one, else, for a
+ * customer-linked model, one per {@link customerSlots} slot, else `fallback`.
+ */
 export function sampleRowCount(modelId, fallback) {
     // Profiles: customers, then vendors, then the pack's instructors.
     if (modelId === PROFILE_MODEL) {
@@ -185,13 +238,19 @@ export function sampleRowCount(modelId, fallback) {
     }
     return (getSamplePack().rowCounts?.[modelId] ??
         SAMPLE_ROW_COUNTS[modelId] ??
-        fallback);
+        (isCustomerLinked(modelId)
+            ? customerSlots(sampleRowCount(CUSTOMER_MODEL, fallback)).length
+            : fallback));
 }
 /**
  * Which row of the target a sample relation points at. Rows are seeded with
- * ids from `(model, index)`, so pointing at index `n` points at a real row.
+ * ids from `(model, index)`, so pointing at index `n` points at a real row;
+ * spread over every row of the target, so each sample record has related
+ * records (a customer several orders, quotes and invoices), not just the
+ * first few.
  */
-function relatedIndex(field, context) {
+export function relatedIndex(field, context) {
+    const rows = context.rows ?? DEFAULT_SAMPLE_ROWS;
     const instructors = getSamplePack().instructors;
     if (field.name === 'organizerId' && instructors?.length) {
         // Organizers lead classes and jobs; they are staff, never customers.
@@ -206,7 +265,13 @@ function relatedIndex(field, context) {
             ? context.index
             : context.index % 8;
     }
-    return context.index % 5;
+    const target = field.related ?? '';
+    if (target === CUSTOMER_MODEL) {
+        // Several rows per customer, 3 to 6 each (see `customerSlots`).
+        const slots = customerSlots(sampleRowCount(CUSTOMER_MODEL, rows));
+        return slots[context.index % slots.length] ?? 0;
+    }
+    return (context.index % (target.includes(':') ? sampleRowCount(target, rows) : rows));
 }
 /** One fake value for a field. Money is an integer number of minor units. */
 export function fakeValue(field, random, context) {
@@ -233,12 +298,12 @@ export function fakeValue(field, random, context) {
         }
         case 'decimal':
             if (/taxrate|vatrate/i.test(field.name)) {
-                // A cookbook's default rate (0: untaxed) beats a random one.
-                const rate = getSampleTaxRate();
-                return rate ?? pick(random, TAX_RATES);
+                // The app's setting, else the pack's (0: untaxed), else 5%.
+                return getSampleTaxRate() ?? DEFAULT_SAMPLE_TAX_RATE;
             }
+            // Exact percent text, as smrt's money model reads it ("10" is 10%).
             if (/discountrate/i.test(field.name))
-                return pick(random, [0, 0.05, 0.1]);
+                return pick(random, ['5', '10']);
             if (/(quantity|qty)/i.test(field.name))
                 return 1 + Math.floor(random() * 5);
             return Math.round(random() * 10000) / 100;
@@ -422,7 +487,7 @@ export function packLine(index) {
     return lines?.length ? lines[index % lines.length] : undefined;
 }
 /** A single seeded record for a model. */
-export function fakeRecord(model, index, seed) {
+export function fakeRecord(model, index, seed, rows) {
     const random = createRandom(hashString(`${seed}:${model.id}:${index}`));
     const record = { id: fakeId(`${model.id}:${index}`) };
     for (const field of model.fields) {
@@ -431,13 +496,72 @@ export function fakeRecord(model, index, seed) {
         record[field.name] = fakeValue(field, random, {
             modelId: model.id,
             index,
+            rows,
         });
     }
     orderDates(model, record, createRandom(hashString(`${seed}:${model.id}:${index}:dates`)));
     nameThings(model, record, index, random);
+    sampleMoneyFields(model, record, index);
     return record;
 }
-/** `count` seeded records for a model. */
-export function fakeRecords(model, count, seed = 1) {
-    return Array.from({ length: count }, (_, i) => fakeRecord(model, i, seed));
+const COMMERCE = '@happyvertical/smrt-commerce:';
+/** Every `EXEMPT_EVERY`th sample customer does not pay sales tax. */
+export const EXEMPT_EVERY = 8;
+/**
+ * The money-model fields of a sample record, set on purpose rather than
+ * drawn: a document is priced the app's way (`lineAmountType`,
+ * `taxRoundingScope`) and is an invoice or a payment, never a credit note or
+ * a refund (those answer an issued document), with no reversal journal or
+ * party tax snapshot; its totals and a line's money
+ * are its document's to settle; tax codes come from the app default, so no
+ * party or product names one of its own; and one customer in eight is tax
+ * exempt.
+ */
+function sampleMoneyFields(model, record, index) {
+    const set = (name, value) => {
+        if (has(model, name))
+            record[name] = value;
+    };
+    for (const name of [
+        'defaultTaxCodeId',
+        'defaultSalesTaxCodeId',
+        'defaultPurchaseTaxCodeId',
+    ]) {
+        set(name, null);
+    }
+    if (!model.id.startsWith(COMMERCE))
+        return;
+    const pricing = getSamplePricing();
+    set('lineAmountType', pricing.pricesIncludeTax ? 'inclusive' : 'exclusive');
+    set('taxRoundingScope', pricing.taxRounding);
+    set('discountTotal', 0);
+    if (model.name === 'Invoice')
+        set('kind', 'invoice');
+    if (model.name === 'Payment')
+        set('kind', 'payment');
+    set('creditedInvoiceId', null);
+    set('creditedLineId', null);
+    set('creditedAmount', 0);
+    // Only a cancelled posted invoice has a reversal journal, and the party's
+    // tax id is snapshotted from the customer when a document is issued.
+    set('arReversalJournalId', null);
+    set('partyTaxId', null);
+    if (isLineModel(model))
+        set('taxAmount', 0);
+    set('taxMode', 'inherit');
+    set('taxCodeId', null);
+    set('taxCodeCode', null);
+    set('taxCodeName', null);
+    if (has(model, 'discountType')) {
+        set('discountType', 'none');
+        set('discountRate', null);
+        set('discount', 0);
+    }
+    if (model.name === 'Customer') {
+        set('taxExempt', index % EXEMPT_EVERY === EXEMPT_EVERY - 1);
+    }
+}
+/** `count` seeded records for a model; `rows` is the source's rows per model. */
+export function fakeRecords(model, count, seed = 1, rows) {
+    return Array.from({ length: count }, (_, i) => fakeRecord(model, i, seed, rows));
 }

package/dist/data/labels.d.ts

@@ -19,8 +19,13 @@ export declare const VENDOR = "@happyvertical/smrt-commerce:Vendor";
 export declare function shortId(id: unknown): string;
 /** Does the model get its name from a Profile (`profileId` referencing one)? */
 export declare function isProfileLabelled(model: CatalogModel): boolean;
-/** The text that names one record. Never an empty string. */
-export declare function recordLabel(source: DataSource, model: CatalogModel, record: ModelRecord, depth?: number): Promise<string>;
+/**
+ * The text that names one record. Never an empty string. `omitParty` names
+ * a party field (`customerId`) whose label to leave out when the record has
+ * a name of its own without it: a customer's page lists its orders as
+ * `TIM-8288`, not `Ridgeline Construction · TIM-8288`.
+ */
+export declare function recordLabel(source: DataSource, model: CatalogModel, record: ModelRecord, depth?: number, omitParty?: string): Promise<string>;
 /**
  * The labels of every record the `fields` of `rows` point at, keyed by
  * {@link labelKey}. A pointer to a record that is gone has no entry, so a view

package/dist/data/labels.js

@@ -36,8 +36,13 @@ async function profileOf(source, record) {
 }
 /** How many relations deep a label may reach (allocation > invoice > customer). */
 const LABEL_DEPTH = 3;
-/** The text that names one record. Never an empty string. */
-export async function recordLabel(source, model, record, depth = 0) {
+/**
+ * The text that names one record. Never an empty string. `omitParty` names
+ * a party field (`customerId`) whose label to leave out when the record has
+ * a name of its own without it: a customer's page lists its orders as
+ * `TIM-8288`, not `Ridgeline Construction · TIM-8288`.
+ */
+export async function recordLabel(source, model, record, depth = 0, omitParty) {
     if (isProfileLabelled(model)) {
         const profile = await profileOf(source, record);
         const name = profile && displayLabel(modelNamed(PROFILE), profile);
@@ -45,6 +50,11 @@ export async function recordLabel(source, model, record, depth = 0) {
             return name;
     }
     const party = partyField(model.fields, record);
+    if (party && party.name === omitParty) {
+        const own = recordName(model, record, () => undefined);
+        if (own)
+            return own;
+    }
     const target = party?.related
         ? getModelByQualifiedName(party.related)?.model
         : undefined;

package/dist/data/list-sort.d.ts

@@ -0,0 +1,8 @@
+/** Sort state belongs to a rendered list, never to its data source. */
+export interface ListSort {
+    key: string;
+    direction: 'ascending' | 'descending';
+}
+export declare function nextListSort(current: ListSort | null, key: string): ListSort;
+/** Stable, non-mutating sort. Empty values remain last in both directions. */
+export declare function sortListRows<T>(rows: readonly T[], sort: ListSort | null, readValue: (row: T, key: string) => unknown): T[];

package/dist/data/list-sort.js

@@ -0,0 +1,45 @@
+export function nextListSort(current, key) {
+    return {
+        key,
+        direction: current?.key === key && current.direction === 'ascending'
+            ? 'descending'
+            : 'ascending',
+    };
+}
+const collator = new Intl.Collator(undefined, {
+    numeric: true,
+    sensitivity: 'base',
+});
+function missing(value) {
+    return (value === null ||
+        value === undefined ||
+        value === '' ||
+        (typeof value === 'number' && !Number.isFinite(value)));
+}
+function compare(a, b) {
+    if (typeof a === 'number' && typeof b === 'number')
+        return a - b;
+    if (typeof a === 'boolean' && typeof b === 'boolean')
+        return Number(a) - Number(b);
+    const left = a instanceof Date ? a.getTime() : a;
+    const right = b instanceof Date ? b.getTime() : b;
+    if (typeof left === 'number' && typeof right === 'number')
+        return left - right;
+    return collator.compare(String(left), String(right));
+}
+/** Stable, non-mutating sort. Empty values remain last in both directions. */
+export function sortListRows(rows, sort, readValue) {
+    if (!sort)
+        return [...rows];
+    return rows
+        .map((row, index) => ({ row, index, value: readValue(row, sort.key) }))
+        .sort((a, b) => {
+        const aMissing = missing(a.value);
+        const bMissing = missing(b.value);
+        if (aMissing !== bMissing)
+            return aMissing ? 1 : -1;
+        const order = aMissing ? 0 : compare(a.value, b.value);
+        return ((sort.direction === 'ascending' ? order : -order) || a.index - b.index);
+    })
+        .map(({ row }) => row);
+}

package/dist/data/money.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Sample document money on smrt-commerce's money model (smrt#3988, released
+ * in 0.56.1). The arithmetic is the package's own: `calculateMoneyDocument`
+ * and `resolveLineTaxCode` from `@happyvertical/smrt-commerce/money` (pure,
+ * browser-safe), never a copy. This module only supplies the sample tenant's
+ * tax codes and maps sample rows to and from the calculator.
+ *
+ * What a settled document holds (minor units throughout):
+ *
+ *   line amount     = quantity x unitPrice - discount
+ *                     exclusive: the line's net; inclusive: its gross, and
+ *                     net = amount - taxAmount
+ *   line taxAmount  = the line's tax from its resolved tax code, one entry
+ *                     per component in `taxComponentsJson`
+ *   subtotal        = the lines' net
+ *   taxAmount       = the lines' tax
+ *   totalAmount     = subtotal + taxAmount
+ *   discountTotal   = the lines' discounts, informational only: they are
+ *                     already inside every line amount and must never be
+ *                     subtracted again
+ *
+ * A line's discount is `discountType` `none`, `percent` (`discountRate` is
+ * exact percent text, "10" is 10%) or `amount` (`discount` in minor units).
+ * Tax codes resolve per line: a line override (`taxMode: 'override'` with
+ * `taxCodeId`), an exempt customer, the product's code, the customer's code,
+ * then the app default.
+ */
+import { type LineAmountType, type MoneyDiscountInput, type TaxCodeAppliesTo, type TaxCodeKind, type TaxRoundingScope } from '@happyvertical/smrt-commerce/money';
+export { MoneyValidationError } from '@happyvertical/smrt-commerce/money';
+export type { LineAmountType, TaxRoundingScope };
+type Row = Readonly<Record<string, unknown>>;
+export interface SampleTaxComponent {
+    id: string;
+    /** The example pack's key, or `cookbook-<percent>` for the default. */
+    key: string;
+    name: string;
+    /** Exact percent text: "7" is 7%. */
+    percent: string;
+    recoverable: boolean;
+}
+export interface SampleTaxCode {
+    id: string;
+    code: string;
+    name: string;
+    kind: TaxCodeKind;
+    appliesTo: TaxCodeAppliesTo;
+    active: boolean;
+    components: readonly SampleTaxComponent[];
+}
+/**
+ * The codes every tenant is seeded with, which report differently and carry
+ * no components.
+ */
+export declare const SEEDED_TAX_CODES: readonly SampleTaxCode[];
+/**
+ * smrt-commerce's `COMMON_TAX_CODE_EXAMPLE_PACK` (Canada GST, BC GST+PST,
+ * Ontario HST, UK VAT, Australian GST, New Zealand GST), as the planner's
+ * tenant has imported it (`applyTaxCodeExamplePack`). The pack is exported
+ * only from the package root, which is not browser-safe, so it is restated
+ * here and `tests/money.test.ts` compares it with the package's; delete the
+ * copy when `./money` exports it (smrt#4023).
+ */
+export declare const TAX_CODE_EXAMPLE_PACK: {
+    readonly id: "common-sales-taxes-v1";
+    readonly components: readonly [{
+        readonly key: "ca-gst-5";
+        readonly name: "Canada GST 5%";
+        readonly percent: "5";
+        readonly recoverable: true;
+    }, {
+        readonly key: "ca-pst-bc-7";
+        readonly name: "BC PST 7%";
+        readonly percent: "7";
+        readonly recoverable: false;
+    }, {
+        readonly key: "ca-hst-on-13";
+        readonly name: "Ontario HST 13%";
+        readonly percent: "13";
+        readonly recoverable: true;
+    }, {
+        readonly key: "uk-vat-20";
+        readonly name: "UK VAT 20%";
+        readonly percent: "20";
+        readonly recoverable: true;
+    }, {
+        readonly key: "au-gst-10";
+        readonly name: "Australia GST 10%";
+        readonly percent: "10";
+        readonly recoverable: true;
+    }, {
+        readonly key: "nz-gst-15";
+        readonly name: "New Zealand GST 15%";
+        readonly percent: "15";
+        readonly recoverable: true;
+    }];
+    readonly codes: readonly [{
+        readonly code: "ca-gst";
+        readonly name: "Canada GST";
+        readonly appliesTo: "both";
+        readonly componentKeys: readonly ["ca-gst-5"];
+    }, {
+        readonly code: "ca-gst-pst-bc";
+        readonly name: "BC GST + PST";
+        readonly appliesTo: "both";
+        readonly componentKeys: readonly ["ca-gst-5", "ca-pst-bc-7"];
+    }, {
+        readonly code: "ca-hst-on";
+        readonly name: "Ontario HST";
+        readonly appliesTo: "both";
+        readonly componentKeys: readonly ["ca-hst-on-13"];
+    }, {
+        readonly code: "uk-vat-standard";
+        readonly name: "UK VAT standard";
+        readonly appliesTo: "both";
+        readonly componentKeys: readonly ["uk-vat-20"];
+    }, {
+        readonly code: "au-gst";
+        readonly name: "Australia GST";
+        readonly appliesTo: "both";
+        readonly componentKeys: readonly ["au-gst-10"];
+    }, {
+        readonly code: "nz-gst";
+        readonly name: "New Zealand GST";
+        readonly appliesTo: "both";
+        readonly componentKeys: readonly ["nz-gst-15"];
+    }];
+};
+/** The example pack's codes with their components. */
+export declare const EXAMPLE_TAX_CODES: readonly SampleTaxCode[];
+/** A fraction (0.0825) as exact percent text ("8.25"). */
+export declare function percentText(rate: number): string;
+/**
+ * The app's default sales tax code for its tax-rate setting, exactly as
+ * smrt-commerce's cookbook activation (`applyCommerceCookbookSettings`)
+ * creates it, so the planner prices what an exported cookbook will: no rate
+ * (0) is `out-of-scope`, any other rate the `default-<rate>` code with one
+ * `Cookbook <rate>%` component. The example pack's codes are only ever chosen
+ * explicitly, on a line (`examplePackCodeFor`).
+ */
+export declare function defaultTaxCode(rate: number): SampleTaxCode;
+/**
+ * The example-pack code a sample line in an app of this currency may choose
+ * for itself: the pack's code with the most components for that country
+ * (BC GST + PST for CAD), else none.
+ */
+export declare function examplePackCodeFor(currency: string): SampleTaxCode | undefined;
+/** Every tax code of the sample tenant: the seeded ones, the default, the pack. */
+export declare function sampleTaxCodes(rate: number): SampleTaxCode[];
+/** The components of the sample tenant's codes, each once. */
+export declare function sampleTaxComponents(codes: readonly SampleTaxCode[]): SampleTaxComponent[];
+/** What a settled line stores per tax component (smrt's `taxComponentsJson`). */
+export interface LineTaxComponent {
+    taxComponentId: string;
+    name: string;
+    percent: string;
+    taxMinor: number;
+}
+/** One `DocumentTax`-shaped row: a code/component's taxable base and tax. */
+export interface DocumentTaxRow {
+    taxCodeId: string | null;
+    taxComponentId: string | null;
+    name: string;
+    percent: string;
+    taxable: number;
+    tax: number;
+}
+export interface MoneyContext {
+    lineAmountType: LineAmountType;
+    roundingScope: TaxRoundingScope;
+    currency: string;
+    codes: readonly SampleTaxCode[];
+    /** The app's default sales code. */
+    appDefaultCodeId: string | null;
+    /** The document's customer is tax exempt. */
+    customerTaxExempt?: boolean;
+    /** The customer's own code (`Customer.defaultTaxCodeId`). */
+    partyCodeId?: string | null;
+    /** A line's product code (`Product.defaultSalesTaxCodeId`), by product id. */
+    productCodeOf?: (productId: string) => string | null | undefined;
+}
+/** The fields a document's calculation writes on each of its lines. */
+export type SettledLineMoney = {
+    discount: number;
+    amount: number;
+    taxAmount: number;
+    taxCodeId: string | null;
+    taxCodeCode: string | null;
+    taxCodeName: string | null;
+    taxComponentsJson: string;
+    taxRate: number;
+};
+export interface SettledDocument<L extends Row> {
+    lines: (L & SettledLineMoney)[];
+    subtotal: number;
+    discountTotal: number;
+    taxAmount: number;
+    totalAmount: number;
+    taxes: DocumentTaxRow[];
+}
+/** A line's discount as the calculator takes it. */
+export declare function lineDiscount(line: Row): MoneyDiscountInput;
+/** A supported ISO 4217 code for the calculator: the row's, else the app's. */
+export declare function moneyCurrency(value: unknown, fallback?: string): string;
+/**
+ * A document's lines and totals on the money model. Each line keeps its own
+ * fields and gains `discount` (what was taken off, in minor units),
+ * `amount`, `taxAmount`, `taxCodeId` / `taxCodeCode` / `taxCodeName`,
+ * `taxComponentsJson` and `taxRate` (the sum of its components' percents as a
+ * fraction, the field smrt keeps beside them). Throws smrt's
+ * `MoneyValidationError` on money the model refuses (a discount above the
+ * line's price, an unknown override code).
+ */
+export declare function settleDocument<L extends Row>(lines: readonly L[], context: MoneyContext): SettledDocument<L>;
+/** The per-component snapshot a settled line stores, or `[]`. */
+export declare function lineTaxComponents(line: Row): LineTaxComponent[];
+/**
+ * A document's per-component tax as its stored line snapshots say: each
+ * component's tax is the sum of what the lines stored for it, and its taxable
+ * base the sum of those lines' net (`amount`, less `taxAmount` when prices
+ * include tax). Sums of stored values only: nothing is recalculated, the way
+ * smrt's `DocumentTax` rows are written from the same calculation.
+ */
+export declare function storedTaxRows(lines: readonly Row[], lineAmountType: LineAmountType): DocumentTaxRow[];
+/** What a line comes to before tax is resolved: its price less its discount. */
+export declare function lineAmount(line: Row): number;