@crewhaus/tool-money 0.7.0

package/dist/lib/match.js

@@ -0,0 +1,136 @@
+/**
+ * Three-way match: invoice against purchase order against goods receipt.
+ *
+ * This is the standard accounts-payable control, and it is entirely
+ * mechanical — pair the lines, compare price and quantity, and report what
+ * falls outside tolerance. A model reading two documents to decide whether
+ * 4,800 matches 4,750 is being paid to do subtraction, and it will sometimes
+ * get it wrong on an invoice nobody re-reads.
+ */
+export const MATCH_STATUSES = [
+    "matched",
+    "price-variance",
+    "quantity-variance",
+    "both-variance",
+    "over-receipt",
+    "not-received",
+];
+/** Lowercased, punctuation folded, runs of space collapsed. */
+function normalizeDescription(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\s]/gu, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function withinTolerance(actual, expected, percentBps, absolute) {
+    const delta = Math.abs(actual - expected);
+    if (delta === 0)
+        return true;
+    // Either bound may pass. A percentage alone is useless on a cheap line and
+    // an absolute alone is useless on an expensive one.
+    const byPercent = percentBps !== undefined && Math.abs(expected) * percentBps >= delta * 10_000;
+    const byAbsolute = absolute !== undefined && delta <= absolute;
+    return byPercent || byAbsolute;
+}
+export function matchInvoiceToPurchaseOrder(invoiceLines, poLines, receiptLines = [], tolerance = {}) {
+    for (const [label, list] of [
+        ["invoice", invoiceLines],
+        ["purchase order", poLines],
+    ]) {
+        const seen = new Set();
+        for (const line of list) {
+            if (seen.has(line.id))
+                throw new Error(`two ${label} lines share the id "${line.id}"`);
+            seen.add(line.id);
+        }
+    }
+    const received = new Map();
+    for (const entry of receiptLines) {
+        received.set(entry.poLineId, (received.get(entry.poLineId) ?? 0) + entry.quantity);
+    }
+    const remainingPo = new Map(poLines.map((l) => [l.id, l]));
+    const pairs = [];
+    const unmatchedInvoiceLines = [];
+    for (const invoice of invoiceLines) {
+        // Reference first, then SKU, then description. Each is weaker than the
+        // one before, and the pair records which was used so a reviewer can see
+        // that a match rested on fuzzy text rather than on an identifier.
+        let po = invoice.poLineId === undefined ? undefined : remainingPo.get(invoice.poLineId);
+        let matchedBy = "reference";
+        if (!po && invoice.sku !== undefined) {
+            po = [...remainingPo.values()].find((l) => l.sku !== undefined && l.sku === invoice.sku);
+            if (po)
+                matchedBy = "sku";
+        }
+        if (!po && invoice.description !== undefined) {
+            const wanted = normalizeDescription(invoice.description);
+            po = [...remainingPo.values()].find((l) => l.description !== undefined && normalizeDescription(l.description) === wanted);
+            if (po)
+                matchedBy = "description";
+        }
+        if (!po) {
+            unmatchedInvoiceLines.push(invoice.id);
+            continue;
+        }
+        remainingPo.delete(po.id);
+        const reasons = [];
+        const priceOk = withinTolerance(invoice.unitPriceMinor, po.unitPriceMinor, tolerance.pricePercentBps, tolerance.priceAbsoluteMinor);
+        const quantityOk = withinTolerance(invoice.quantity, po.quantity, tolerance.quantityPercentBps, tolerance.quantityAbsolute);
+        if (!priceOk) {
+            reasons.push(`unit price ${invoice.unitPriceMinor} against ${po.unitPriceMinor} on the order`);
+        }
+        if (!quantityOk) {
+            reasons.push(`quantity ${invoice.quantity} against ${po.quantity} on the order`);
+        }
+        const receivedQuantity = received.has(po.id) ? received.get(po.id) : null;
+        let status = !priceOk && !quantityOk
+            ? "both-variance"
+            : !priceOk
+                ? "price-variance"
+                : !quantityOk
+                    ? "quantity-variance"
+                    : "matched";
+        // The receipt is the third leg: billing for more than arrived is the
+        // failure this control exists to catch, and it is invisible in a two-way
+        // match however well price and quantity agree with the order.
+        if (receiptLines.length > 0) {
+            if (receivedQuantity === null || receivedQuantity === 0) {
+                status = "not-received";
+                reasons.push("nothing has been received against this order line");
+            }
+            else if (invoice.quantity > receivedQuantity) {
+                status = "over-receipt";
+                reasons.push(`invoiced ${invoice.quantity} but only ${receivedQuantity} received`);
+            }
+        }
+        const billable = Math.min(invoice.quantity, receivedQuantity ?? invoice.quantity);
+        const exposureMinor = invoice.quantity * invoice.unitPriceMinor -
+            billable * Math.min(invoice.unitPriceMinor, po.unitPriceMinor);
+        pairs.push({
+            invoiceLineId: invoice.id,
+            poLineId: po.id,
+            matchedBy,
+            status,
+            invoiceUnitPriceMinor: invoice.unitPriceMinor,
+            poUnitPriceMinor: po.unitPriceMinor,
+            priceDeltaMinor: invoice.unitPriceMinor - po.unitPriceMinor,
+            invoiceQuantity: invoice.quantity,
+            poQuantity: po.quantity,
+            receivedQuantity,
+            quantityDelta: invoice.quantity - po.quantity,
+            exposureMinor: status === "matched" ? 0 : exposureMinor,
+            reasons,
+        });
+    }
+    const exceptions = pairs.filter((p) => p.status !== "matched").length;
+    return {
+        pairs,
+        unmatchedInvoiceLines,
+        unmatchedPoLines: [...remainingPo.keys()],
+        ok: exceptions === 0 && unmatchedInvoiceLines.length === 0,
+        exceptions,
+        totalExposureMinor: pairs.reduce((s, p) => s + p.exposureMinor, 0),
+        threeWay: receiptLines.length > 0,
+    };
+}

package/dist/lib/statement.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Normalize a bank, card or exchange export into one transaction list.
+ *
+ * Two things in this job corrupt ledgers quietly, and both are guessed at by
+ * every convenient importer:
+ *
+ * - **Date order.** `03/04/2026` is 3 April in most of the world and 4 March
+ *   in the United States. Nothing in the file says which, and a wrong guess
+ *   moves transactions between months — so a file whose dates are ambiguous
+ *   is REFUSED unless the caller states the order, rather than parsed into
+ *   something that looks fine.
+ * - **Sign.** Some exports use a signed amount, some a debit column and a
+ *   credit column, and some a positive amount with a separate direction. Get
+ *   it backwards and a reconciliation balances to exactly twice the error.
+ *
+ * Only what the file says is reported. No categorization, no counterparty
+ * enrichment, no guessing at what a memo line means.
+ */
+export declare const DATE_ORDERS: readonly ["iso", "dmy", "mdy"];
+export type DateOrder = (typeof DATE_ORDERS)[number];
+export declare const STATEMENT_FORMATS: readonly ["csv", "ofx"];
+export type StatementFormat = (typeof STATEMENT_FORMATS)[number];
+export type Transaction = {
+    /** The file's own id where it has one, otherwise a stable positional id. */
+    readonly id: string;
+    /** ISO-8601 date, always. */
+    readonly date: string;
+    readonly description: string;
+    /** Minor units, negative for money leaving the account. */
+    readonly amountMinor: number;
+    readonly direction: "debit" | "credit";
+    readonly reference: string;
+    readonly balanceMinor: number | null;
+};
+export type ParseOptions = {
+    readonly format?: StatementFormat;
+    readonly dateOrder?: DateOrder;
+    /** Decimal comma and dot-as-thousands, as much of Europe writes it. */
+    readonly decimalComma?: boolean;
+    /** Column names, when the header does not use recognizable ones. */
+    readonly columns?: {
+        readonly date?: string;
+        readonly description?: string;
+        readonly amount?: string;
+        readonly debit?: string;
+        readonly credit?: string;
+        readonly balance?: string;
+        readonly reference?: string;
+    };
+    /** Currency's minor-unit exponent. 2 for most, 0 for JPY. */
+    readonly decimals?: number;
+};
+export type ParseResult = {
+    readonly format: StatementFormat;
+    readonly transactions: ReadonlyArray<Transaction>;
+    readonly count: number;
+    readonly totalMinor: number;
+    readonly debitMinor: number;
+    readonly creditMinor: number;
+    readonly dateOrder: DateOrder;
+    /** Rows the file contained that could not be read, with the reason. */
+    readonly rejected: ReadonlyArray<{
+        readonly row: number;
+        readonly reason: string;
+    }>;
+};
+/** RFC 4180 fields: quotes, doubled quotes inside them, embedded newlines. */
+export declare function parseCsvRows(text: string): string[][];
+/** Parse a money string to minor units, exactly, without floating point. */
+export declare function parseMoneyMinor(raw: string, decimals: number, decimalComma: boolean): number | null;
+/**
+ * Parse a date, refusing what cannot be read unambiguously.
+ *
+ * Returns null rather than a guess. The caller turns that into a rejected
+ * row with a reason, which is recoverable; a silently wrong month is not.
+ */
+export declare function parseDate(raw: string, order: DateOrder): string | null;
+/** True when every slashed date in the file reads the same either way. */
+export declare function datesAreUnambiguous(values: ReadonlyArray<string>): boolean;
+export declare function parseStatement(text: string, options?: ParseOptions): ParseResult;

package/dist/lib/statement.js

@@ -0,0 +1,296 @@
+/**
+ * Normalize a bank, card or exchange export into one transaction list.
+ *
+ * Two things in this job corrupt ledgers quietly, and both are guessed at by
+ * every convenient importer:
+ *
+ * - **Date order.** `03/04/2026` is 3 April in most of the world and 4 March
+ *   in the United States. Nothing in the file says which, and a wrong guess
+ *   moves transactions between months — so a file whose dates are ambiguous
+ *   is REFUSED unless the caller states the order, rather than parsed into
+ *   something that looks fine.
+ * - **Sign.** Some exports use a signed amount, some a debit column and a
+ *   credit column, and some a positive amount with a separate direction. Get
+ *   it backwards and a reconciliation balances to exactly twice the error.
+ *
+ * Only what the file says is reported. No categorization, no counterparty
+ * enrichment, no guessing at what a memo line means.
+ */
+export const DATE_ORDERS = ["iso", "dmy", "mdy"];
+export const STATEMENT_FORMATS = ["csv", "ofx"];
+/** RFC 4180 fields: quotes, doubled quotes inside them, embedded newlines. */
+export function parseCsvRows(text) {
+    const rows = [];
+    let row = [];
+    let field = "";
+    let quoted = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (quoted) {
+            if (ch === '"') {
+                if (text[i + 1] === '"') {
+                    field += '"';
+                    i++;
+                }
+                else
+                    quoted = false;
+            }
+            else
+                field += ch;
+            continue;
+        }
+        if (ch === '"')
+            quoted = true;
+        else if (ch === ",") {
+            row.push(field);
+            field = "";
+        }
+        else if (ch === "\n") {
+            row.push(field);
+            rows.push(row);
+            row = [];
+            field = "";
+        }
+        else if (ch !== "\r")
+            field += ch;
+    }
+    if (field !== "" || row.length > 0) {
+        row.push(field);
+        rows.push(row);
+    }
+    return rows.filter((r) => r.some((f) => f.trim() !== ""));
+}
+/** Parse a money string to minor units, exactly, without floating point. */
+export function parseMoneyMinor(raw, decimals, decimalComma) {
+    let text = raw.trim();
+    if (text === "")
+        return null;
+    let negative = false;
+    // Accounting negatives are parenthesised, and a trailing sign is common.
+    if (/^\(.*\)$/.test(text)) {
+        negative = true;
+        text = text.slice(1, -1);
+    }
+    if (text.endsWith("-")) {
+        negative = true;
+        text = text.slice(0, -1);
+    }
+    text = text.replace(/[^\d.,+-]/g, "");
+    if (text.startsWith("-")) {
+        negative = !negative;
+        text = text.slice(1);
+    }
+    else if (text.startsWith("+"))
+        text = text.slice(1);
+    const groupSeparator = decimalComma ? "." : ",";
+    const decimalSeparator = decimalComma ? "," : ".";
+    text = text.split(groupSeparator).join("");
+    const parts = text.split(decimalSeparator);
+    if (parts.length > 2)
+        return null;
+    const whole = parts[0] ?? "";
+    const fraction = parts[1] ?? "";
+    if (!/^\d*$/.test(whole) || !/^\d*$/.test(fraction))
+        return null;
+    if (whole === "" && fraction === "")
+        return null;
+    // Pad or truncate to the currency's exponent rather than rounding a float.
+    const scaled = `${whole}${fraction.padEnd(decimals, "0").slice(0, decimals)}`;
+    const value = Number.parseInt(scaled === "" ? "0" : scaled, 10);
+    return negative ? -value : value;
+}
+/**
+ * Parse a date, refusing what cannot be read unambiguously.
+ *
+ * Returns null rather than a guess. The caller turns that into a rejected
+ * row with a reason, which is recoverable; a silently wrong month is not.
+ */
+export function parseDate(raw, order) {
+    const text = raw.trim();
+    const iso = /^(\d{4})-(\d{2})-(\d{2})/.exec(text);
+    if (iso)
+        return `${iso[1]}-${iso[2]}-${iso[3]}`;
+    // OFX and several exports use YYYYMMDD, optionally with a time after it.
+    const compact = /^(\d{4})(\d{2})(\d{2})/.exec(text);
+    if (compact)
+        return `${compact[1]}-${compact[2]}-${compact[3]}`;
+    const slashed = /^(\d{1,2})[/.-](\d{1,2})[/.-](\d{2,4})$/.exec(text);
+    if (slashed) {
+        if (order === "iso")
+            return null;
+        const first = Number(slashed[1]);
+        const second = Number(slashed[2]);
+        let year = Number(slashed[3]);
+        if (year < 100)
+            year += year < 70 ? 2000 : 1900;
+        const day = order === "dmy" ? first : second;
+        const month = order === "dmy" ? second : first;
+        if (month < 1 || month > 12 || day < 1 || day > 31)
+            return null;
+        return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+    }
+    return null;
+}
+/** True when every slashed date in the file reads the same either way. */
+export function datesAreUnambiguous(values) {
+    for (const value of values) {
+        const slashed = /^(\d{1,2})[/.-](\d{1,2})[/.-](\d{2,4})$/.exec(value.trim());
+        if (!slashed)
+            continue;
+        const first = Number(slashed[1]);
+        const second = Number(slashed[2]);
+        // Both readable as a month means the file cannot settle the question.
+        if (first <= 12 && second <= 12 && first !== second)
+            return false;
+    }
+    return true;
+}
+const COLUMN_ALIASES = {
+    date: ["date", "transaction date", "posted date", "posting date", "value date", "booking date"],
+    description: ["description", "details", "narrative", "memo", "payee", "name", "reference text"],
+    amount: ["amount", "value", "transaction amount"],
+    debit: ["debit", "withdrawal", "withdrawals", "money out", "paid out", "charge"],
+    credit: ["credit", "deposit", "deposits", "money in", "paid in"],
+    balance: ["balance", "running balance", "closing balance"],
+    reference: ["reference", "ref", "transaction id", "id", "cheque number"],
+};
+function findColumn(headers, role, override) {
+    if (override !== undefined) {
+        const at = headers.findIndex((h) => h.toLowerCase() === override.toLowerCase());
+        if (at === -1)
+            throw new Error(`the file has no column named "${override}"`);
+        return at;
+    }
+    const aliases = COLUMN_ALIASES[role] ?? [];
+    return headers.findIndex((h) => aliases.includes(h.trim().toLowerCase()));
+}
+export function parseStatement(text, options = {}) {
+    const format = options.format ?? (/<OFX>|<STMTTRN>/i.test(text) ? "ofx" : "csv");
+    const decimals = options.decimals ?? 2;
+    const decimalComma = options.decimalComma === true;
+    const rejected = [];
+    const transactions = [];
+    if (format === "ofx") {
+        // OFX is SGML with optional closing tags; the transaction blocks are all
+        // that matters here and they are regular enough to read directly.
+        const blocks = text.match(/<STMTTRN>[\s\S]*?<\/STMTTRN>/gi) ?? [];
+        const field = (block, tag) => {
+            const m = new RegExp(`<${tag}>([^<\\r\\n]*)`, "i").exec(block);
+            return (m?.[1] ?? "").trim();
+        };
+        for (const [i, block] of blocks.entries()) {
+            const date = parseDate(field(block, "DTPOSTED"), "iso");
+            const amount = parseMoneyMinor(field(block, "TRNAMT"), decimals, false);
+            if (date === null || amount === null) {
+                rejected.push({ row: i + 1, reason: "the transaction has no readable date or amount" });
+                continue;
+            }
+            const name = field(block, "NAME") || field(block, "MEMO");
+            transactions.push({
+                id: field(block, "FITID") || `ofx-${i + 1}`,
+                date,
+                description: name,
+                amountMinor: amount,
+                direction: amount < 0 ? "debit" : "credit",
+                reference: field(block, "CHECKNUM") || field(block, "REFNUM"),
+                balanceMinor: null,
+            });
+        }
+    }
+    else {
+        const rows = parseCsvRows(text);
+        if (rows.length < 2) {
+            throw new Error("the CSV has no data rows under its header");
+        }
+        const headers = rows[0].map((h) => h.trim());
+        const at = {
+            date: findColumn(headers, "date", options.columns?.date),
+            description: findColumn(headers, "description", options.columns?.description),
+            amount: findColumn(headers, "amount", options.columns?.amount),
+            debit: findColumn(headers, "debit", options.columns?.debit),
+            credit: findColumn(headers, "credit", options.columns?.credit),
+            balance: findColumn(headers, "balance", options.columns?.balance),
+            reference: findColumn(headers, "reference", options.columns?.reference),
+        };
+        if (at.date === -1) {
+            throw new Error(`no date column found; the header is: ${headers.join(", ")}`);
+        }
+        if (at.amount === -1 && at.debit === -1 && at.credit === -1) {
+            throw new Error(`no amount, debit or credit column found; the header is: ${headers.join(", ")}`);
+        }
+        const body = rows.slice(1);
+        const rawDates = body.map((r) => r[at.date] ?? "");
+        let order = options.dateOrder;
+        if (order === undefined) {
+            if (!datesAreUnambiguous(rawDates)) {
+                throw new Error("the dates in this file could be day-first or month-first and the file does not say which; pass dateOrder explicitly rather than have the months guessed at");
+            }
+            order = rawDates.some((d) => /^\d{1,2}[/.-]/.test(d.trim())) ? "dmy" : "iso";
+        }
+        for (const [i, row] of body.entries()) {
+            const date = parseDate(row[at.date] ?? "", order);
+            if (date === null) {
+                rejected.push({
+                    row: i + 2,
+                    reason: `"${row[at.date] ?? ""}" is not a date this can read`,
+                });
+                continue;
+            }
+            let amountMinor = null;
+            if (at.amount !== -1) {
+                amountMinor = parseMoneyMinor(row[at.amount] ?? "", decimals, decimalComma);
+            }
+            if (amountMinor === null && (at.debit !== -1 || at.credit !== -1)) {
+                const debit = at.debit === -1 ? null : parseMoneyMinor(row[at.debit] ?? "", decimals, decimalComma);
+                const credit = at.credit === -1 ? null : parseMoneyMinor(row[at.credit] ?? "", decimals, decimalComma);
+                // A debit column holds a positive number meaning money out, so the
+                // sign has to be applied rather than read.
+                if (debit !== null && debit !== 0)
+                    amountMinor = -Math.abs(debit);
+                else if (credit !== null && credit !== 0)
+                    amountMinor = Math.abs(credit);
+            }
+            if (amountMinor === null) {
+                rejected.push({ row: i + 2, reason: "no readable amount in this row" });
+                continue;
+            }
+            transactions.push({
+                id: (at.reference !== -1 ? row[at.reference] : "") || `row-${i + 2}`,
+                date,
+                description: (at.description === -1 ? "" : (row[at.description] ?? "")).trim(),
+                amountMinor,
+                direction: amountMinor < 0 ? "debit" : "credit",
+                reference: at.reference === -1 ? "" : (row[at.reference] ?? "").trim(),
+                balanceMinor: at.balance === -1 ? null : parseMoneyMinor(row[at.balance] ?? "", decimals, decimalComma),
+            });
+        }
+        return {
+            format,
+            transactions,
+            count: transactions.length,
+            totalMinor: transactions.reduce((s, t) => s + t.amountMinor, 0),
+            debitMinor: transactions
+                .filter((t) => t.direction === "debit")
+                .reduce((s, t) => s + t.amountMinor, 0),
+            creditMinor: transactions
+                .filter((t) => t.direction === "credit")
+                .reduce((s, t) => s + t.amountMinor, 0),
+            dateOrder: order,
+            rejected,
+        };
+    }
+    return {
+        format,
+        transactions,
+        count: transactions.length,
+        totalMinor: transactions.reduce((s, t) => s + t.amountMinor, 0),
+        debitMinor: transactions
+            .filter((t) => t.direction === "debit")
+            .reduce((s, t) => s + t.amountMinor, 0),
+        creditMinor: transactions
+            .filter((t) => t.direction === "credit")
+            .reduce((s, t) => s + t.amountMinor, 0),
+        dateOrder: "iso",
+        rejected,
+    };
+}

package/dist/lib/tax.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Per-line tax from an operator's own rate tables.
+ *
+ * Money is integer minor units throughout — cents, pence, satoshi-free. A
+ * tax engine that computes in floating point produces totals that do not add
+ * up, and "off by a cent" in an invoice is not a rounding detail, it is a
+ * document that fails an audit.
+ *
+ * Two choices are the caller's and neither has a safe default, so both are
+ * explicit: whether listed prices already include tax, and whether rounding
+ * happens per line or once per invoice. Jurisdictions differ, the totals
+ * differ, and a tool that picked one silently would be wrong half the time.
+ */
+export declare const ROUNDING_MODES: readonly ["half-up", "half-even", "down", "up"];
+export type RoundingMode = (typeof ROUNDING_MODES)[number];
+export declare const ROUNDING_SCOPES: readonly ["line", "invoice"];
+export type RoundingScope = (typeof ROUNDING_SCOPES)[number];
+export type TaxRate = {
+    readonly code: string;
+    /** Basis points: 2000 is 20%. Integer, so the rate itself never rounds. */
+    readonly bps: number;
+    readonly name?: string;
+    /**
+     * Charged on the running total including earlier taxes, rather than on the
+     * net amount. Quebec's QST historically worked this way, and getting it
+     * wrong changes the total rather than a rounding digit.
+     */
+    readonly compound?: boolean;
+};
+export type TaxLine = {
+    readonly id: string;
+    /** Minor units. Net of tax unless `pricesIncludeTax` is set. */
+    readonly amountMinor: number;
+    /** Rate codes applied to this line, in order. */
+    readonly taxCodes: ReadonlyArray<string>;
+    /** Exempt from tax entirely, which is not the same as a zero rate. */
+    readonly exempt?: boolean;
+};
+export type TaxOptions = {
+    readonly pricesIncludeTax?: boolean;
+    readonly rounding?: RoundingMode;
+    readonly scope?: RoundingScope;
+    /**
+     * B2B cross-border: the customer accounts for the tax, so the invoice
+     * carries none. It is reported rather than silently zero, because an
+     * invoice that shows no tax for the wrong reason is a compliance problem.
+     */
+    readonly reverseCharge?: boolean;
+};
+export type TaxLineResult = {
+    readonly id: string;
+    readonly netMinor: number;
+    readonly taxMinor: number;
+    readonly grossMinor: number;
+    readonly breakdown: ReadonlyArray<{
+        readonly code: string;
+        readonly bps: number;
+        readonly taxMinor: number;
+    }>;
+    readonly note: string;
+};
+export type TaxResult = {
+    readonly lines: ReadonlyArray<TaxLineResult>;
+    readonly netMinor: number;
+    readonly taxMinor: number;
+    readonly grossMinor: number;
+    readonly byCode: ReadonlyArray<{
+        readonly code: string;
+        readonly bps: number;
+        readonly taxMinor: number;
+        readonly netMinor: number;
+    }>;
+    readonly reverseCharge: boolean;
+    readonly rounding: RoundingMode;
+    readonly scope: RoundingScope;
+};
+/** Round a rational to an integer, by the caller's rule. */
+export declare function roundMinor(numerator: number, denominator: number, mode: RoundingMode): number;
+export declare function calculateTax(lines: ReadonlyArray<TaxLine>, rates: ReadonlyArray<TaxRate>, options?: TaxOptions): TaxResult;