@happyvertical/smrt-commerce 0.53.3 → 0.53.5

package/dist/svelte/invoices/calculations.js

@@ -0,0 +1,259 @@
+/** Exact, transport-neutral invoice draft validation shared by browser and server. */
+import { currencyMinorUnitExponent } from './currency.js';
+const MAX_MINOR = BigInt(Number.MAX_SAFE_INTEGER);
+const MAX_TEXT = 128;
+function decimal(value, precision) {
+    if (typeof value !== 'string' ||
+        value.length > MAX_TEXT ||
+        !/^\d+(?:\.\d+)?$/.test(value))
+        return 'invalid-decimal';
+    const [whole, fraction = ''] = value.split('.');
+    if (fraction.length > precision)
+        return 'precision';
+    return {
+        coefficient: BigInt(whole + fraction),
+        scale: 10n ** BigInt(fraction.length),
+    };
+}
+function roundHalfUp(numerator, denominator) {
+    return (numerator * 2n + denominator) / (denominator * 2n);
+}
+function minor(value, digits) {
+    const parsed = decimal(value, MAX_TEXT);
+    if (typeof parsed === 'string')
+        return parsed;
+    const scaled = parsed.coefficient * 10n ** BigInt(digits);
+    if (scaled % parsed.scale !== 0n)
+        return 'precision';
+    const result = scaled / parsed.scale;
+    return result > MAX_MINOR ? 'range' : result;
+}
+function rate(value) {
+    const parsed = decimal(value, 6);
+    if (typeof parsed === 'string')
+        return parsed;
+    return parsed.coefficient > 100n * parsed.scale ? 'range' : parsed;
+}
+function numberDecimal(value, precision) {
+    if (!Number.isFinite(value) || value < 0 || value > Number.MAX_SAFE_INTEGER)
+        throw new RangeError('Invoice rate or quantity is outside the supported range.');
+    // The shortest canonical decimal preserves the caller's Number. toFixed can
+    // invent different decimal digits that round back to that same binary value.
+    const [mantissa, exponent = '0'] = value.toString().split('e');
+    const [whole, fraction = ''] = mantissa.split('.');
+    const places = fraction.length - Number(exponent);
+    if (places > precision)
+        throw new RangeError('Invoice rate or quantity exceeds the supported decimal precision.');
+    const coefficient = BigInt(whole + fraction);
+    return places < 0
+        ? { coefficient: coefficient * 10n ** BigInt(-places), scale: 1n }
+        : { coefficient, scale: 10n ** BigInt(places) };
+}
+function roundSigned(numerator, denominator) {
+    // Preserve Math.round's existing credit-line ties toward positive infinity.
+    return numerator >= 0n
+        ? roundHalfUp(numerator, denominator)
+        : -((-numerator * 2n + denominator - 1n) / (denominator * 2n));
+}
+/**
+ * Exact model calculation, including existing negative-price credit lines.
+ * Throws before persistence for unsafe money, invalid quantity, or invalid tax.
+ */
+export function calculateInvoiceMinorLine(input) {
+    for (const amount of [input.unitPrice, input.discount])
+        if (!Number.isSafeInteger(amount))
+            throw new RangeError('Invoice money must be safe integer minor units.');
+    if (input.discount < 0 || input.taxRate > 1)
+        throw new RangeError('Invoice discount or tax rate is outside the supported range.');
+    const quantity = numberDecimal(input.quantity, 6);
+    const tax = numberDecimal(input.taxRate, 8);
+    const gross = roundSigned(quantity.coefficient * BigInt(input.unitPrice), quantity.scale);
+    const discount = BigInt(input.discount);
+    const subtotal = gross - discount;
+    const taxMinor = roundSigned(subtotal * tax.coefficient, tax.scale);
+    const total = subtotal + taxMinor;
+    for (const amount of [gross, subtotal, taxMinor, total])
+        if (amount > MAX_MINOR || amount < -MAX_MINOR)
+            throw new RangeError('Invoice line amount exceeds safe integer minor units.');
+    return {
+        grossMinor: Number(gross),
+        discountMinor: input.discount,
+        subtotalMinor: Number(subtotal),
+        taxMinor: Number(taxMinor),
+        totalMinor: Number(total),
+    };
+}
+/**
+ * Resolve a validated editor draft to model fields. Percentage discounts become
+ * exact flat minor units; inherited tax becomes the authorized effective rate.
+ * Keep the raw draft alongside these fields when reopening its editing modes.
+ */
+export function resolveInvoiceLineDraft(line, context) {
+    const result = calculateInvoiceLine(line, context);
+    if (!result.valid)
+        throw new RangeError(`Invalid invoice line: ${JSON.stringify(result.errors)}`);
+    const quantity = Number(line.quantity);
+    const sourceQuantity = decimal(line.quantity, 6);
+    const storedQuantity = numberDecimal(quantity, 6);
+    if (typeof sourceQuantity === 'string' ||
+        sourceQuantity.coefficient * storedQuantity.scale !==
+            storedQuantity.coefficient * sourceQuantity.scale)
+        throw new RangeError('Invoice quantity cannot round-trip through numeric persistence.');
+    const [whole, fraction = ''] = result.effectiveTaxRate.split('.');
+    const rateDigits = BigInt(whole + fraction)
+        .toString()
+        .padStart(fraction.length + 3, '0');
+    const split = rateDigits.length - fraction.length - 2;
+    const taxRate = Number(`${rateDigits.slice(0, split)}.${rateDigits.slice(split)}`);
+    const unitPrice = minor(line.unitPrice, currencyMinorUnitExponent(context.currency));
+    if (typeof unitPrice !== 'bigint')
+        throw new RangeError('Invalid invoice unit price.');
+    const resolved = {
+        description: line.description,
+        sku: line.sku,
+        quantity,
+        unitPrice: Number(unitPrice),
+        discount: result.discountMinor,
+        taxRate,
+        amount: result.totalMinor,
+    };
+    const model = calculateInvoiceMinorLine(resolved);
+    if (model.totalMinor !== result.totalMinor ||
+        model.subtotalMinor !== result.subtotalMinor ||
+        model.taxMinor !== result.taxMinor)
+        throw new RangeError('Invoice draft and persisted calculation disagree.');
+    return resolved;
+}
+/**
+ * Validate and calculate one line using decimal integer arithmetic. Round half
+ * up separately at gross, percentage discount, and tax boundaries. No rounding
+ * is permitted when parsing a price or flat discount into currency minor units.
+ */
+export function calculateInvoiceLine(line, context) {
+    const errors = {};
+    if (!line.key?.trim())
+        errors.key = 'required';
+    if (!line.description?.trim())
+        errors.description = 'required';
+    if (!/^[A-Z]{3}$/.test(context.currency))
+        return { valid: false, errors: { unitPrice: 'invalid-currency' } };
+    const digits = currencyMinorUnitExponent(context.currency);
+    const quantity = decimal(line.quantity, 6);
+    const price = minor(line.unitPrice, digits);
+    if (typeof quantity === 'string')
+        errors.quantity = quantity;
+    else if (quantity.coefficient > MAX_MINOR * quantity.scale)
+        errors.quantity = 'range';
+    else {
+        try {
+            const persisted = numberDecimal(Number(line.quantity), 6);
+            if (quantity.coefficient * persisted.scale !==
+                persisted.coefficient * quantity.scale)
+                errors.quantity = 'precision';
+        }
+        catch {
+            errors.quantity = 'precision';
+        }
+    }
+    if (typeof price === 'string')
+        errors.unitPrice = price;
+    if (line.discountType !== 'flat' && line.discountType !== 'percent')
+        errors.discountType = 'invalid-mode';
+    if (line.taxMode !== 'inherit' && line.taxMode !== 'override')
+        errors.taxMode = 'invalid-mode';
+    const discount = line.discountType === 'percent'
+        ? rate(line.discountValue)
+        : minor(line.discountValue, digits);
+    if (typeof discount === 'string')
+        errors.discountValue = discount;
+    const effectiveTaxRate = line.taxMode === 'inherit' ? context.inheritedTaxRate : line.taxRate;
+    const tax = rate(effectiveTaxRate);
+    if (typeof tax === 'string')
+        errors.taxRate = tax;
+    if (Object.keys(errors).length ||
+        typeof quantity === 'string' ||
+        typeof price === 'string' ||
+        typeof discount === 'string' ||
+        typeof tax === 'string')
+        return { valid: false, errors };
+    const gross = roundHalfUp(quantity.coefficient * price, quantity.scale);
+    const reduction = typeof discount === 'bigint'
+        ? discount
+        : roundHalfUp(gross * discount.coefficient, discount.scale * 100n);
+    if (gross > MAX_MINOR)
+        return { valid: false, errors: { quantity: 'range' } };
+    if (reduction > gross)
+        return {
+            valid: false,
+            errors: { discountValue: 'discount-exceeds-gross' },
+        };
+    const subtotal = gross - reduction;
+    const taxMinor = roundHalfUp(subtotal * tax.coefficient, tax.scale * 100n);
+    const total = subtotal + taxMinor;
+    if (total > MAX_MINOR)
+        return { valid: false, errors: { taxRate: 'range' } };
+    return {
+        valid: true,
+        effectiveTaxRate,
+        grossMinor: Number(gross),
+        discountMinor: Number(reduction),
+        subtotalMinor: Number(subtotal),
+        taxMinor: Number(taxMinor),
+        totalMinor: Number(total),
+    };
+}
+function calendarDate(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || value.startsWith('0000'))
+        return false;
+    const date = new Date(`${value}T00:00:00.000Z`);
+    return (Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value);
+}
+/** Validate the header and sum validated lines without floating-point arithmetic. */
+export function calculateInvoiceDraft(values) {
+    const errors = {};
+    if (!values.customerId?.trim())
+        errors.customerId = 'required';
+    if (!calendarDate(values.issuedOn))
+        errors.issuedOn = 'invalid-date';
+    if (!calendarDate(values.dueOn) || values.dueOn < values.issuedOn)
+        errors.dueOn = 'invalid-date';
+    if (!/^[A-Z]{3}$/.test(values.currency))
+        errors.currency = 'invalid-currency';
+    const inheritedRate = rate(values.taxRate);
+    if (typeof inheritedRate === 'string')
+        errors.taxRate = inheritedRate;
+    if (values.lines.length === 0)
+        errors.lines = 'required';
+    if (new Set(values.lines.map((line) => line.key)).size !== values.lines.length)
+        errors.lines = 'duplicate-key';
+    const lineResults = values.lines.map((line) => calculateInvoiceLine(line, {
+        currency: values.currency,
+        inheritedTaxRate: values.taxRate,
+    }));
+    const sums = {
+        grossMinor: 0n,
+        discountMinor: 0n,
+        subtotalMinor: 0n,
+        taxMinor: 0n,
+        totalMinor: 0n,
+    };
+    for (const result of lineResults) {
+        if (!result.valid)
+            continue;
+        for (const key of Object.keys(sums))
+            sums[key] += BigInt(result[key]);
+    }
+    if (Object.values(sums).some((value) => value > MAX_MINOR))
+        errors.total = 'range';
+    if (Object.keys(errors).length || lineResults.some((result) => !result.valid))
+        return { valid: false, errors, lineResults };
+    return {
+        valid: true,
+        lineResults,
+        grossMinor: Number(sums.grossMinor),
+        discountMinor: Number(sums.discountMinor),
+        subtotalMinor: Number(sums.subtotalMinor),
+        taxMinor: Number(sums.taxMinor),
+        totalMinor: Number(sums.totalMinor),
+    };
+}

package/dist/svelte/invoices/currency.d.ts

@@ -0,0 +1,9 @@
+/** Svelte-free currency precision shared by invoice previews and billing. */
+/** Upper-case, validate, and return an ISO 4217-shaped currency code. */
+export declare function normalizeCurrency(currency: string): string;
+/**
+ * The ISO 4217 minor-unit exponent of a currency (2 for USD and RSD, 0 for
+ * JPY, 3 for IQD). Any code not listed as 0, 3, or 4 is 2.
+ */
+export declare function currencyMinorUnitExponent(currency: string): number;
+//# sourceMappingURL=currency.d.ts.map

package/dist/svelte/invoices/currency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"currency.d.ts","sourceRoot":"","sources":["../../../src/svelte/invoices/currency.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAI7E,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAuCD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElE"}

package/dist/svelte/invoices/currency.js

@@ -0,0 +1,55 @@
+/** Svelte-free currency precision shared by invoice previews and billing. */
+const CURRENCY_PATTERN = /^[A-Z]{3}$/;
+/** Upper-case, validate, and return an ISO 4217-shaped currency code. */
+export function normalizeCurrency(currency) {
+    const code = String(currency ?? '')
+        .trim()
+        .toUpperCase();
+    if (!CURRENCY_PATTERN.test(code)) {
+        throw new Error(`Currency '${currency}' must be a three-letter code.`);
+    }
+    return code;
+}
+/**
+ * ISO 4217 minor-unit exponents other than 2, matching
+ * `@happyvertical/accounting`'s table (sdk#1269). An explicit table, not the
+ * runtime's `Intl` display digits: CLDR rounds some currencies for display
+ * (IQD, MGA, and ALL show 0 decimals) and its data changes between ICU
+ * releases (RSD has shown both 0 and 2), which would put minor units off by a
+ * power of ten against the SDK.
+ */
+const ISO_EXPONENTS = {
+    BIF: 0,
+    CLP: 0,
+    DJF: 0,
+    GNF: 0,
+    ISK: 0,
+    JPY: 0,
+    KMF: 0,
+    KRW: 0,
+    PYG: 0,
+    RWF: 0,
+    UGX: 0,
+    UYI: 0,
+    VND: 0,
+    VUV: 0,
+    XAF: 0,
+    XOF: 0,
+    XPF: 0,
+    BHD: 3,
+    IQD: 3,
+    JOD: 3,
+    KWD: 3,
+    LYD: 3,
+    OMR: 3,
+    TND: 3,
+    CLF: 4,
+    UYW: 4,
+};
+/**
+ * The ISO 4217 minor-unit exponent of a currency (2 for USD and RSD, 0 for
+ * JPY, 3 for IQD). Any code not listed as 0, 3, or 4 is 2.
+ */
+export function currencyMinorUnitExponent(currency) {
+    return ISO_EXPONENTS[normalizeCurrency(currency)] ?? 2;
+}

package/dist/svelte/invoices/fields.d.ts

@@ -0,0 +1,6 @@
+import type { InvoiceFieldNames, InvoiceLineFieldNames } from './types.js';
+/** Stable native header field defaults. */
+export declare const invoiceFieldNames: InvoiceFieldNames;
+/** Stable repeated native line field defaults. */
+export declare const invoiceLineFieldNames: InvoiceLineFieldNames;
+//# sourceMappingURL=fields.d.ts.map

package/dist/svelte/invoices/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../../src/svelte/invoices/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC3E,2CAA2C;AAC3C,eAAO,MAAM,iBAAiB,EAAE,iBAQ/B,CAAC;AACF,kDAAkD;AAClD,eAAO,MAAM,qBAAqB,EAAE,qBAUnC,CAAC"}

package/dist/svelte/invoices/fields.js

@@ -0,0 +1,22 @@
+/** Stable native header field defaults. */
+export const invoiceFieldNames = {
+    customerId: 'customerId',
+    issuedOn: 'issuedOn',
+    dueOn: 'dueOn',
+    currency: 'currency',
+    paymentTerms: 'paymentTerms',
+    taxRate: 'invoiceTaxRate',
+    intent: 'intent',
+};
+/** Stable repeated native line field defaults. */
+export const invoiceLineFieldNames = {
+    key: 'lineKey',
+    description: 'lineDescription',
+    sku: 'lineSku',
+    quantity: 'lineQuantity',
+    unitPrice: 'lineUnitPrice',
+    discountType: 'lineDiscountType',
+    discountValue: 'lineDiscountValue',
+    taxMode: 'lineTaxMode',
+    taxRate: 'lineTaxRate',
+};

package/dist/svelte/invoices/messages.d.ts

@@ -0,0 +1,53 @@
+export declare const invoicePreparationMessages: {
+    readonly 'commerce.preparation.title': "commerce.preparation.title";
+    readonly 'commerce.invoice.customer': "commerce.invoice.customer";
+    readonly 'commerce.invoice.chooseCustomer': "commerce.invoice.chooseCustomer";
+    readonly 'commerce.invoice.issued': "commerce.invoice.issued";
+    readonly 'commerce.invoice.due': "commerce.invoice.due";
+    readonly 'commerce.invoice.currency': "commerce.invoice.currency";
+    readonly 'commerce.invoice.terms': "commerce.invoice.terms";
+    readonly 'commerce.invoice.defaultTax': "commerce.invoice.defaultTax";
+    readonly 'commerce.invoice.line': "commerce.invoice.line";
+    readonly 'commerce.invoice.description': "commerce.invoice.description";
+    readonly 'commerce.invoice.sku': "commerce.invoice.sku";
+    readonly 'commerce.invoice.quantity': "commerce.invoice.quantity";
+    readonly 'commerce.invoice.unitPrice': "commerce.invoice.unitPrice";
+    readonly 'commerce.invoice.discountType': "commerce.invoice.discountType";
+    readonly 'commerce.invoice.flat': "commerce.invoice.flat";
+    readonly 'commerce.invoice.percent': "commerce.invoice.percent";
+    readonly 'commerce.invoice.discountValue': "commerce.invoice.discountValue";
+    readonly 'commerce.invoice.taxMode': "commerce.invoice.taxMode";
+    readonly 'commerce.invoice.inherit': "commerce.invoice.inherit";
+    readonly 'commerce.invoice.override': "commerce.invoice.override";
+    readonly 'commerce.invoice.taxRate': "commerce.invoice.taxRate";
+    readonly 'commerce.invoice.remove': "commerce.invoice.remove";
+    readonly 'commerce.invoice.add': "commerce.invoice.add";
+    readonly 'commerce.invoice.empty': "commerce.invoice.empty";
+    readonly 'commerce.invoice.gross': "commerce.invoice.gross";
+    readonly 'commerce.invoice.discount': "commerce.invoice.discount";
+    readonly 'commerce.invoice.subtotal': "commerce.invoice.subtotal";
+    readonly 'commerce.invoice.tax': "commerce.invoice.tax";
+    readonly 'commerce.invoice.total': "commerce.invoice.total";
+    readonly 'commerce.invoice.invalid': "commerce.invoice.invalid";
+    readonly 'commerce.invoice.preview': "commerce.invoice.preview";
+    readonly 'commerce.invoice.retained': "commerce.invoice.retained";
+    readonly 'commerce.preparation.allocation': "commerce.preparation.allocation";
+    readonly 'commerce.preparation.source': "commerce.preparation.source";
+    readonly 'commerce.preparation.reference': "commerce.preparation.reference";
+    readonly 'commerce.preparation.choose': "commerce.preparation.choose";
+    readonly 'commerce.preparation.retained': "commerce.preparation.retained";
+    readonly 'commerce.preparation.available': "commerce.preparation.available";
+    readonly 'commerce.preparation.amount': "commerce.preparation.amount";
+    readonly 'commerce.preparation.help': "commerce.preparation.help";
+    readonly 'commerce.preparation.remove': "commerce.preparation.remove";
+    readonly 'commerce.preparation.add': "commerce.preparation.add";
+    readonly 'commerce.preparation.save': "commerce.preparation.save";
+    readonly 'commerce.preparation.cancel': "commerce.preparation.cancel";
+    readonly 'commerce.preparation.restricted': "commerce.preparation.restricted";
+    readonly 'commerce.preparation.empty': "commerce.preparation.empty";
+    readonly 'commerce.preparation.no_rows': "commerce.preparation.no_rows";
+    readonly 'commerce.preparation.readonly': "commerce.preparation.readonly";
+    readonly 'commerce.preparation.uncertain': "commerce.preparation.uncertain";
+    readonly 'commerce.preparation.review': "commerce.preparation.review";
+};
+//# sourceMappingURL=messages.d.ts.map

package/dist/svelte/invoices/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/svelte/invoices/messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DrC,CAAC"}

package/dist/svelte/invoices/messages.js

@@ -0,0 +1,53 @@
+import { defineMessages } from '@happyvertical/smrt-ui/i18n';
+export const invoicePreparationMessages = defineMessages({
+    'commerce.preparation.title': 'Prepare invoice',
+    'commerce.invoice.customer': 'Customer',
+    'commerce.invoice.chooseCustomer': 'Choose a customer',
+    'commerce.invoice.issued': 'Invoice date',
+    'commerce.invoice.due': 'Due date',
+    'commerce.invoice.currency': 'Currency',
+    'commerce.invoice.terms': 'Payment terms',
+    'commerce.invoice.defaultTax': 'Default tax (%)',
+    'commerce.invoice.line': 'Invoice line {number}',
+    'commerce.invoice.description': 'Description',
+    'commerce.invoice.sku': 'SKU',
+    'commerce.invoice.quantity': 'Quantity',
+    'commerce.invoice.unitPrice': 'Unit price ({currency})',
+    'commerce.invoice.discountType': 'Discount type',
+    'commerce.invoice.flat': 'Flat amount',
+    'commerce.invoice.percent': 'Percentage',
+    'commerce.invoice.discountValue': 'Discount value',
+    'commerce.invoice.taxMode': 'Tax mode',
+    'commerce.invoice.inherit': 'Inherit default tax',
+    'commerce.invoice.override': 'Override tax',
+    'commerce.invoice.taxRate': 'Line tax (%)',
+    'commerce.invoice.remove': 'Remove line',
+    'commerce.invoice.add': 'Add line',
+    'commerce.invoice.empty': 'No invoice lines. Add a line to begin.',
+    'commerce.invoice.gross': 'Gross',
+    'commerce.invoice.discount': 'Discount',
+    'commerce.invoice.subtotal': 'Subtotal',
+    'commerce.invoice.tax': 'Tax',
+    'commerce.invoice.total': 'Total',
+    'commerce.invoice.invalid': 'Totals unavailable until quantity, price, discount, tax and currency are valid.',
+    'commerce.invoice.preview': 'Calculated preview; the server revalidates prices, tax and totals.',
+    'commerce.invoice.retained': 'Retained reference: {reference}',
+    'commerce.preparation.allocation': 'Allocation {number}',
+    'commerce.preparation.source': 'Reviewed source',
+    'commerce.preparation.reference': 'Source reference',
+    'commerce.preparation.choose': 'Choose a source or leave this row blank',
+    'commerce.preparation.retained': 'Retained source reference: {reference}',
+    'commerce.preparation.available': '{label} · Available: {amount} {currency} minor units',
+    'commerce.preparation.amount': 'Amount ({currency})',
+    'commerce.preparation.help': 'Enter currency amounts, for example 125.00 for CAD. The server validates currency precision and source availability.',
+    'commerce.preparation.remove': 'Remove this allocation',
+    'commerce.preparation.add': 'Add allocation row',
+    'commerce.preparation.save': 'Save invoice draft',
+    'commerce.preparation.cancel': 'Cancel',
+    'commerce.preparation.restricted': 'Source details are restricted. Enter references supplied through your authorized workflow.',
+    'commerce.preparation.empty': 'No reviewed sources are available. Retained references remain visible for review.',
+    'commerce.preparation.no_rows': 'No allocations. Add a row to prepare this draft.',
+    'commerce.preparation.readonly': 'This draft is read-only.',
+    'commerce.preparation.uncertain': 'The outcome is uncertain. Your values and request identity are retained; follow your application’s retry guidance.',
+    'commerce.preparation.review': 'Invoice review',
+});

package/dist/svelte/invoices/types.d.ts

@@ -0,0 +1,194 @@
+import type { FormRetryStatus } from '@happyvertical/smrt-ui/form-retry';
+import type { Snippet } from 'svelte';
+import type { HTMLFormAttributes } from 'svelte/elements';
+/** Authorized source projection supplied by the application, not fetched by UI. */
+export interface InvoicePreparationSource {
+    /** Opaque source reference submitted verbatim. */
+    id: string;
+    /** Caller-localized source description. */
+    label: string;
+    /** Available integer minor units, including this draft's reservation if editing. */
+    availableMinor: number;
+    /** Whether the caller permits selecting this source now. */
+    selectable?: boolean;
+}
+/** Lossless native-form values; even invalid submitted strings remain visible. */
+export interface InvoiceAllocationDraft {
+    /** Stable row identity, unique within one editor. Never minted as a request key. */
+    key: string;
+    /** Source reference, including references no longer in the source list. */
+    sourceId: string;
+    /** Currency-unit text as entered (e.g. CAD 125.00). Server parses currency precision. */
+    amount: string;
+    /** Retained native removal selection after a rejected action. */
+    remove?: boolean;
+    /** Caller validation feedback for the source field. */
+    sourceError?: string;
+    /** Caller validation feedback for the amount field. */
+    amountError?: string;
+}
+/** Server-authoritative presentation snapshot; no status is inferred from edits. */
+export interface InvoicePreparationReview {
+    /** Caller-localized state, including unknown/future states. */
+    label: string;
+    /** Caller explanation of approval, invalidation, expiry or review requirements. */
+    message?: string;
+}
+/** Native name mapping for adapters. Row names repeat in displayed order. */
+export interface InvoicePreparationFields {
+    /** Source identifier field, default sourceId. */
+    source: string;
+    /** Currency-unit text field, default allocationAmount. */
+    amount: string;
+    /** Checked zero-based row positions, default removeRow. */
+    remove: string;
+    /** Clicked submitter name, default intent. */
+    intent: string;
+}
+/** Explicit caller request values; arrays preserve repeated native fields. */
+export interface InvoicePreparationHiddenField {
+    /** Native request field name. */
+    name: string;
+    /** Value forwarded without normalization or rotation. */
+    value: string;
+}
+/** Invoice draft types shared with the Svelte-free exact calculator. */
+export type { InvoiceDraftValues, InvoiceLineDraft } from './calculations.js';
+import type { InvoiceDraftValues, InvoiceLineDraft } from './calculations.js';
+/** Optional allocation fields, rendered without an enclosing form. */
+export interface InvoiceAllocationFieldsProps {
+    /** Currency for allocation presentation. */
+    currency: string;
+    /** Retained source-allocation rows. */
+    allocations: readonly InvoiceAllocationDraft[];
+    /** Authorized source projections only. */
+    sources?: readonly InvoicePreparationSource[];
+    /** Hide sensitive source labels and balances when false. */
+    mayReadSources?: boolean;
+    /** Presentation capability; server authorizes every action. */
+    canEdit?: boolean;
+    /** Disable the structural add action while pending. */
+    pending?: boolean;
+    /** Native allocation field adapters. */
+    fields?: Partial<InvoicePreparationFields>;
+    /** Native add-allocation intent, default addAllocation. */
+    addIntent?: string;
+    /** Stable label identity. */
+    id?: string;
+}
+/** Editable line field names repeat in displayed order. */
+export interface InvoiceLineFieldNames {
+    /** Stable line identity. */
+    key: string;
+    /** Description text. */
+    description: string;
+    /** Product/SKU reference text. */
+    sku: string;
+    /** Fractional quantity text. */
+    quantity: string;
+    /** Currency-unit price text. */
+    unitPrice: string;
+    /** Flat or percentage discount selection. */
+    discountType: string;
+    /** Currency-unit or percent discount text. */
+    discountValue: string;
+    /** Inherited or explicit tax selection. */
+    taxMode: string;
+    /** Explicit percentage tax text, including zero. */
+    taxRate: string;
+}
+/** Invoice header and submitter name adapters. */
+export interface InvoiceFieldNames {
+    /** Customer reference. */
+    customerId: string;
+    /** Invoice date text. */
+    issuedOn: string;
+    /** Due date text. */
+    dueOn: string;
+    /** Currency code. */
+    currency: string;
+    /** Payment terms text. */
+    paymentTerms: string;
+    /** Default tax percentage text. */
+    taxRate: string;
+    /** Clicked submitter name. */
+    intent: string;
+}
+/** General invoice line fields; never renders a nested form. */
+export interface InvoiceLineEditorProps {
+    /** Lossless caller-owned line values. */
+    line: InvoiceLineDraft;
+    /** Current currency code for shared calculation. */
+    currency: string;
+    /** External default tax percentage; explicit line override remains distinct. */
+    inheritedTaxRate: string;
+    /** One-based display position. */
+    number?: number;
+    /** Stable control-label prefix. */
+    id?: string;
+    /** Native field-name adapters. */
+    fields?: Partial<InvoiceLineFieldNames>;
+    /** Caller errors keyed by canonical line field name. */
+    errors?: Partial<Record<keyof InvoiceLineFieldNames, string>>;
+    /** Presentation capability. */
+    canEdit?: boolean;
+    /** Disable structural actions while pending. */
+    pending?: boolean;
+    /** Native submitter name. */
+    intentField?: string;
+    /** Remove intent prefix, followed by caller line key. */
+    removePrefix?: string;
+    /** Optional notification with a new lossless draft; the supplied line is never mutated. */
+    onchange?: (line: InvoiceLineDraft) => void;
+}
+/** General native invoice editor with optional domain extensions. */
+export interface InvoiceEditorProps {
+    /** Caller native endpoint. */
+    action: string;
+    /** Native method, default POST. */
+    method?: 'post' | 'get';
+    /** Stable form identity. */
+    id?: string;
+    /** Caller-localized title. */
+    title?: string;
+    /** Retained editable strings; never reconstructed from model numbers. */
+    values: InvoiceDraftValues;
+    /** Authorized customer projections; retained unknown references stay visible. */
+    customers?: readonly {
+        id: string;
+        label: string;
+    }[];
+    /** Caller field errors: header name or lineKey.fieldName. */
+    errors?: Record<string, string>;
+    /** Header and submitter field adapters. */
+    fields?: Partial<InvoiceFieldNames>;
+    /** Repeated line field adapters. */
+    lineFields?: Partial<InvoiceLineFieldNames>;
+    /** Presentation capability only; server reauthorizes all mutations. */
+    canEdit?: boolean;
+    /** Disable submission while a request is pending. */
+    pending?: boolean;
+    /** Caller-owned retry-controller status. */
+    retryStatus?: FormRetryStatus;
+    /** Caller error or uncertain-outcome message. */
+    message?: string;
+    /** Server-authoritative review snapshot. */
+    review?: InvoicePreparationReview;
+    /** Exact caller tokens/context; repeated names preserved. */
+    hiddenFields?: readonly InvoicePreparationHiddenField[];
+    /** Save intent, default save. */
+    saveIntent?: string;
+    /** Add-line intent, default addLine. */
+    addIntent?: string;
+    /** Remove-line intent prefix, default removeLine:. */
+    removePrefix?: string;
+    /** Caller-localized save label. */
+    saveLabel?: string;
+    /** Optional cancel navigation URL. */
+    cancelHref?: string;
+    /** Domain fields inside the single form; receives current draft for currency-aware extensions. */
+    children?: Snippet<[InvoiceDraftValues]>;
+    /** Optional enhancement; native submission remains the default. */
+    onsubmit?: HTMLFormAttributes['onsubmit'];
+}
+//# sourceMappingURL=types.d.ts.map