@nxgt/material 3.75.0 → 3.76.0

package/dist/lib/components/ui/widgets/calculator/variants/conversion/conversion-result.d.ts

@@ -0,0 +1,15 @@
+import { ConversionOutcome } from './conversion-math.js';
+import { RatesState } from './conversion-rates.js';
+/** The quote date in the locale; a date-only text is read as UTC so the day never moves. */
+export declare function formatAsOf(asOf: string, locale?: string): string;
+/** How the rates stand: loading, failed (with a retry), or the date they were quoted. */
+export declare function RatesStatus({ rates, locale, retry, }: {
+    rates: RatesState;
+    locale?: string;
+    retry?: () => void;
+}): import("react").JSX.Element | null;
+/** The answer, large; its symbol beside it; the engine's message when it failed. */
+export declare function ConversionResult({ outcome, symbol, }: {
+    outcome: ConversionOutcome;
+    symbol: string;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/conversion/conversion-state.d.ts

@@ -0,0 +1,36 @@
+/** What the panel remembers: the category, the units chosen and the value typed. */
+export type ConversionState = {
+    readonly category: string;
+    /** `''` until chosen: the category's default unit is shown. */
+    readonly from: string;
+    readonly to: string;
+    readonly text: string;
+};
+export type ConversionAction = {
+    type: 'category';
+    id: string;
+} | {
+    type: 'from';
+    id: string;
+    units: readonly string[];
+} | {
+    type: 'to';
+    id: string;
+    units: readonly string[];
+} | {
+    type: 'swap';
+    from: string;
+    to: string;
+} | {
+    type: 'text';
+    text: string;
+};
+export declare const INITIAL_CONVERSION: ConversionState;
+/** The unit ids of a category: the table's, or `currencies` for the currency. */
+export declare function categoryUnits(category: string, currencies: readonly string[]): readonly string[];
+/**
+ * The units to show: the chosen ones while they belong to the category, else
+ * its defaults, and never the same unit twice.
+ */
+export declare function pickPair(state: Pick<ConversionState, 'category' | 'from' | 'to'>, units: readonly string[]): readonly [string, string];
+export declare function conversionReducer(state: ConversionState, action: ConversionAction): ConversionState;

package/dist/lib/components/ui/widgets/calculator/variants/conversion/conversion-variant.d.ts

@@ -0,0 +1,3 @@
+import { VariantModule } from '../variant-loader.js';
+/** The Conversion variant as one on-demand chunk: its fields, tables and maths. */
+export declare const variant: VariantModule;

package/dist/lib/components/ui/widgets/calculator/variants/conversion/use-conversion.d.ts

@@ -0,0 +1,24 @@
+/** The panel's state and what it shows: the units, the outcome, what is said. */
+export declare function useConversion(): {
+    state: import('./conversion-state.js').ConversionState;
+    dispatch: import('react').ActionDispatch<[action: import('./conversion-state.js').ConversionAction]>;
+    category: string;
+    rates: import('./conversion-rates.js').RatesState;
+    retry: (() => void) | undefined;
+    locale: string | undefined;
+    units: readonly string[];
+    from: string;
+    to: string;
+    options: {
+        id: string;
+        label: string;
+    }[];
+    categories: {
+        id: string;
+        label: string;
+    }[];
+    waiting: boolean;
+    outcome: import('./conversion-math.js').ConversionOutcome;
+    toLabel: import('./conversion-labels.js').UnitLabel;
+    said: string | null;
+};

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-change.d.ts

@@ -0,0 +1,4 @@
+/** Percent change from one figure to another, and the difference. */
+export declare function FinancialChange({ active }: {
+    active: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-figures.d.ts

@@ -0,0 +1,43 @@
+import { CalcErrorCode, Decimal } from '@nxgt/material-core/calculator';
+import { CalculatorMessage } from '../../types.js';
+/** How a figure is written: an amount in the currency, a percent, or a plain number. */
+export type FigureUnit = 'money' | 'percent' | 'number';
+export type Figure = {
+    readonly id: string;
+    readonly label: CalculatorMessage;
+    readonly value: Decimal;
+    readonly unit: FigureUnit;
+    /** The answer the live region reads, bold on screen. */
+    readonly main?: boolean;
+};
+/** What a calculation gives: figures, an engine error, or `null` while the fields are not filled. */
+export type Outcome = {
+    readonly figures: readonly Figure[];
+} | {
+    readonly error: CalcErrorCode;
+} | null;
+/** A field's value: a number, or `null` while it is empty. */
+export type Input = number | null;
+declare const KEYS: {
+    readonly net: "material.calculator.financial.figure.net";
+    readonly vat: "material.calculator.financial.figure.vat";
+    readonly gross: "material.calculator.financial.figure.gross";
+    readonly margin: "material.calculator.financial.figure.margin";
+    readonly markup: "material.calculator.financial.figure.markup";
+    readonly profit: "material.calculator.financial.figure.profit";
+    readonly price: "material.calculator.financial.figure.price";
+    readonly cost: "material.calculator.financial.figure.cost";
+    readonly change: "material.calculator.financial.figure.change";
+    readonly difference: "material.calculator.financial.figure.difference";
+    readonly payment: "material.calculator.financial.figure.payment";
+    readonly interest: "material.calculator.financial.figure.interest";
+    readonly total: "material.calculator.financial.figure.total";
+    readonly 'last-payment': "material.calculator.financial.figure.last-payment";
+};
+export declare const fig: (id: keyof typeof KEYS, fallback: string, value: Decimal, unit: FigureUnit, main?: boolean) => Figure;
+/** Runs `build` when every input is filled; an engine error becomes its code. */
+export declare function outcome(inputs: readonly Input[], build: (n: readonly string[]) => readonly Figure[]): Outcome;
+export type MoneyDigits = {
+    readonly fractionDigits: number;
+};
+export {};

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-format.d.ts

@@ -0,0 +1,12 @@
+import { Decimal } from '@nxgt/material-core/calculator';
+import { Figure } from './financial-figures.js';
+export type FigureFormat = {
+    readonly locale?: string;
+    /** ISO 4217 code written after amounts; none writes none. */
+    readonly currency?: string;
+    readonly fractionDigits: number;
+};
+/** A percent in `locale`: `33.33 %`, without float arithmetic. */
+export declare const formatPercent: (d: Decimal, locale?: string) => string;
+/** A figure as text, by its unit. */
+export declare const formatFigure: (figure: Figure, f: FigureFormat) => string;

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-loan-math.d.ts

@@ -0,0 +1,14 @@
+import { amortisation } from '@nxgt/material-core/calculator/financial';
+import { Input, MoneyDigits, Outcome } from './financial-figures.js';
+/** The most rows of the amortisation table shown. */
+export declare const TABLE_ROWS = 12;
+export type LoanResult = {
+    readonly rows: ReturnType<typeof amortisation>['rows'];
+    readonly periods: number;
+    readonly truncated: boolean;
+};
+/** The payment of a loan, its totals and the first rows of its schedule. */
+export declare function loanOutcome(principal: Input, rate: Input, periods: Input, o: MoneyDigits): {
+    outcome: Outcome;
+    loan: LoanResult | null;
+};

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-loan.d.ts

@@ -0,0 +1,4 @@
+/** A loan: its monthly payment, the totals and the first rows of its schedule. */
+export declare function FinancialLoan({ active }: {
+    active: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-margin.d.ts

@@ -0,0 +1,4 @@
+/** Margin and markup: the rates of a cost and a price, or the price or the cost a rate gives. */
+export declare function FinancialMargin({ active }: {
+    active: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-math.d.ts

@@ -0,0 +1,10 @@
+import { Input, MoneyDigits, Outcome } from './financial-figures.js';
+export type VatMode = 'add' | 'remove';
+/** The VAT of a price: added on a net price, or taken out of a gross one. */
+export declare const vatOutcome: (mode: VatMode, amount: Input, rate: Input, o: MoneyDigits) => Outcome;
+export type MarginMode = 'rates' | 'price' | 'cost';
+export type MarginBasis = 'margin' | 'markup';
+/** Rates of a cost and a price; the price of a cost and a rate; or the cost. */
+export declare const marginOutcome: (mode: MarginMode, basis: MarginBasis, first: Input, second: Input, o: MoneyDigits) => Outcome;
+/** The change from one figure to another, in percent and as a difference. */
+export declare const changeOutcome: (from: Input, to: Input) => Outcome;

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-panel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The Financial variant's body, in place of the display and the keypad: four
+ * calculations in sub-tabs (VAT, margin and markup, percent change, loan with
+ * its schedule). Plain local state; every tab stays mounted so what was typed
+ * is still there when it is opened again.
+ */
+export declare function FinancialPanel(): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-parts.d.ts

@@ -0,0 +1,35 @@
+import { Input, Outcome } from './financial-figures.js';
+import { FigureFormat } from './financial-format.js';
+/** Currency, minor-unit digits and locale of the panel, from the calculator. */
+export declare function useFigureFormat(): FigureFormat;
+type FieldProps = {
+    label: string;
+    value: Input;
+    onChange: (value: Input) => void;
+};
+/**
+ * An amount: the library's CurrencyField in the calculator's currency, or a
+ * plain NumberField when none is set (no code to show).
+ */
+export declare function AmountField({ label, value, onChange }: FieldProps): import("react").JSX.Element;
+/** A percent (0 to `max`): the library's PercentField. */
+export declare function RateField({ max, ...props }: FieldProps & {
+    max?: number;
+}): import("react").JSX.Element;
+/** A plain number (a count, a figure to compare): NumberField without steppers. */
+export declare function CountField({ min, max, ...props }: FieldProps & {
+    min?: number;
+    max?: number;
+}): import("react").JSX.Element;
+/** The figures of an outcome, or its error, or the hint while it is empty. */
+export declare function Results({ outcome, active, }: {
+    outcome: Outcome;
+    active: boolean;
+}): import("react").JSX.Element;
+/** A choice of a `Segment`: the text is both what is drawn and its name. */
+export declare const choice: <T extends string>(id: T, text: string) => {
+    id: T;
+    glyph: string;
+    name: string;
+};
+export {};

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-table.d.ts

@@ -0,0 +1,7 @@
+import { FigureFormat } from './financial-format.js';
+import { LoanResult } from './financial-loan-math.js';
+/** The first payments of a loan: a real table, captioned, one row per payment. */
+export declare function AmortisationTable({ loan, format, }: {
+    loan: LoanResult;
+    format: FigureFormat;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-variant.d.ts

@@ -0,0 +1,3 @@
+import { VariantModule } from '../variant-loader.js';
+/** The Financial variant as one on-demand chunk: its forms and their maths. */
+export declare const variant: VariantModule;

package/dist/lib/components/ui/widgets/calculator/variants/financial/financial-vat.d.ts

@@ -0,0 +1,4 @@
+/** VAT: add it to a price excluding VAT, or take it out of one that includes it. */
+export declare function FinancialVat({ active }: {
+    active: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/key-layout.d.ts

@@ -0,0 +1,51 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+import { CalculatorMessage } from '../types.js';
+import { POS_NAMES } from './pos/pos-names.js';
+import { PROGRAMMER_NAMES } from './programmer/programmer-names.js';
+import { SCIENTIFIC_NAMES } from './scientific/scientific-names.js';
+/** What a key looks like: its shape and colour follow the role. */
+export type KeyRole = 'digit' | 'operator' | 'equals' | 'utility' | 'function' | 'memory'
+/** ( and ): small keys like the memory ones. */
+ | 'bracket';
+export type KeyDef = {
+    readonly id: string;
+    /** The engine key it presses. */
+    readonly key: CalcKey;
+    /** What is drawn; `aria-hidden`, the spoken name is `name`. */
+    readonly glyph: string;
+    readonly role: KeyRole;
+    /** The spoken name, the button's `aria-label`. */
+    readonly name: CalculatorMessage;
+    /** Grid units spanned, 1 by default. */
+    readonly span?: number;
+    /** What the key is on the second page (2nd): same place, another key. */
+    readonly alt?: KeyAlt;
+    /** Keys pressed one after the other, instead of `key` (`EE` is `* 10 ^`). */
+    readonly sequence?: readonly CalcKey[];
+};
+/** A key's second-page face: it keeps the button, so focus stays put. */
+export type KeyAlt = Pick<KeyDef, 'key' | 'glyph' | 'name'>;
+/** Keys by rows on a grid of `columns`. */
+export type KeyLayout = {
+    readonly columns: number;
+    readonly rows: readonly (readonly KeyDef[])[];
+    /**
+     * The first `split` rows are a pane of their own (the scientific
+     * functions): above the rest on a phone, beside it from 600px.
+     */
+    readonly split?: number;
+};
+/** The spoken names, as the `material.calculator.keys.*` leaves. */
+export type KeyName = (typeof DIGIT_NAMES)[number] | 'decimal' | 'add' | 'subtract' | 'multiply' | 'divide' | 'equals' | 'clear' | 'backspace' | 'sign' | 'percent' | 'open-paren' | 'close-paren' | 'memory-clear' | 'memory-recall' | 'memory-add' | 'memory-subtract' | (typeof SCIENTIFIC_NAMES)[number] | (typeof POS_NAMES)[number] | (typeof PROGRAMMER_NAMES)[number];
+export declare const msg: (name: KeyName, fallback: string) => CalculatorMessage;
+export declare const key: (id: string, k: CalcKey, glyph: string, role: KeyRole, name: KeyName, fallback: string, span?: number) => KeyDef;
+export declare const DIGIT_NAMES: readonly ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"];
+export declare const digit: (n: number, span?: number) => KeyDef;
+/** `( ) MC MR M+ M-`: six small keys, two grid units each (twelve units a row). */
+export declare const MEMORY_ROW: readonly KeyDef[];
+/** A row of four keys, three grid units each, on the twelve-unit grid. */
+export declare const wide: (keys: readonly KeyDef[]) => readonly KeyDef[];
+/** The key a pressed `def` stands for on page one or, with 2nd, page two. */
+export declare const faceOf: (def: KeyDef, second: boolean) => KeyDef;
+/** The keys a press of `def` sends to the engine, in order. */
+export declare const keysOf: (def: KeyDef) => readonly CalcKey[];

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-announce.d.ts

@@ -0,0 +1,16 @@
+import { Announcement } from '../../calculator-announce.js';
+import { PosAction, PosEnv, PosState } from './pos-types.js';
+/** What the live region needs to word an amount. */
+export type PosFormat = {
+    locale?: string;
+    denominations: readonly string[];
+};
+/** The change to give back, or what is still due: after a tender is entered. */
+export declare function settlementMessage(s: PosState, env: PosEnv, f: PosFormat): Announcement | null;
+export declare const totalMessage: (s: PosState, env: PosEnv, f: PosFormat) => Announcement;
+/**
+ * The live region after `action`: the total when the ticket changed, the
+ * change or the amount still due when a tender is entered. Typing digits is
+ * never announced.
+ */
+export declare function announcePos(prev: PosState, next: PosState, action: PosAction, env: PosEnv, f: PosFormat): Announcement | null;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-aside.d.ts

@@ -0,0 +1,2 @@
+/** Beside the keys (below on a phone): the ticket and the payment. */
+export declare function PosAside(): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-display.d.ts

@@ -0,0 +1,2 @@
+/** The big line is what is being typed; the total sits above it. */
+export declare function PosDisplay(): import("react").JSX.Element | null;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-fields.d.ts

@@ -0,0 +1,2 @@
+/** What the keys type into, the kind of discount, and the VAT. */
+export declare function PosFields(): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-layout.d.ts

@@ -0,0 +1,9 @@
+import { KeyLayout } from '../key-layout.js';
+/**
+ * A till's keys on twelve units: digits, `00`, a quantity key (`×`),
+ * a discount key (`%`) and `+` to add the amount to the ticket. The keys are
+ * the engine's, the point-of-sale panel decides what each one does.
+ */
+export declare const POS_LAYOUT: KeyLayout;
+/** The keys the physical keyboard takes: the keypad's own, nothing more. */
+export declare const POS_EXTRA_KEYS: readonly [];

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-line.d.ts

@@ -0,0 +1,6 @@
+import { PosLine } from './pos-types.js';
+/** One line of the ticket: its name, quantity and price, its total, and a way to remove it. */
+export declare function PosLineRow({ line, index }: {
+    line: PosLine;
+    index: number;
+}): import("react").JSX.Element | null;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-names.d.ts

@@ -0,0 +1,2 @@
+/** The spoken names of the point-of-sale keys: `material.calculator.keys.<name>`. */
+export declare const POS_NAMES: readonly ["double-zero", "quantity", "discount", "add-line"];

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-state.d.ts

@@ -0,0 +1,3 @@
+import { PosAction, PosEnv, PosState } from './pos-types.js';
+/** The panel's state after `action`. Pure; the ticket is built from it. */
+export declare function reducePos(s: PosState, action: PosAction, env: PosEnv): PosState;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-tender.d.ts

@@ -0,0 +1,2 @@
+/** Bills to hand over, the change due, and the Charge button. */
+export declare function PosTender(): import("react").JSX.Element | null;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-ticket-data.d.ts

@@ -0,0 +1,41 @@
+import { Totals } from '@nxgt/material-core/calculator/pos';
+import { PosEnv, PosState } from './pos-types.js';
+/** A discount as handed to `onCharge`: a percent or an amount, as plain text. */
+export type PosTicketDiscount = {
+    readonly percent: string;
+} | {
+    readonly amount: string;
+};
+/**
+ * What `onCharge` receives: plain data, JSON-safe. Amounts are text with the
+ * currency's decimals (`'12.50'`), rates and quantities are plain numbers as
+ * text (`'5.5'`).
+ */
+export type PosTicket = {
+    readonly currency?: string;
+    /** True when the prices on the lines include the VAT. */
+    readonly taxInclusive: boolean;
+    readonly lines: readonly {
+        readonly id: string;
+        readonly unitPrice: string;
+        readonly quantity: string;
+        /** The VAT rate in percent. */
+        readonly vatRate: string;
+        readonly discount?: PosTicketDiscount;
+        /** The line's total with the VAT, after its discounts. */
+        readonly total: string;
+    }[];
+    readonly discount?: PosTicketDiscount;
+    readonly totals: {
+        readonly subtotal: string;
+        readonly discount: string;
+        readonly vatByRate: readonly {
+            readonly rate: string;
+            readonly base: string;
+            readonly vat: string;
+        }[];
+        readonly total: string;
+    };
+};
+/** The ticket to hand over for a charge, from the state and its totals. */
+export declare function plainTicket(s: PosState, totals: Totals, env: PosEnv): PosTicket;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-ticket.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The ticket: its lines, removable one by one, and the totals. On a phone it
+ * folds away so the keys stay in view; from 600px it is always open.
+ */
+export declare function PosTicket(): import("react").JSX.Element | null;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-totals.d.ts

@@ -0,0 +1,2 @@
+/** Subtotal, discount, VAT by rate and the total, as a description list. */
+export declare function PosTotals(): import("react").JSX.Element | null;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-types.d.ts

@@ -0,0 +1,76 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+export type PosField = 'price' | 'quantity' | 'discount' | 'tender';
+export type DiscountKind = 'percent' | 'amount';
+/** A discount as typed: a whole percent, or an amount in minor units. */
+export type PosDiscount = {
+    kind: DiscountKind;
+    value: string;
+};
+/** One line of the ticket, as strings: price in minor units. */
+export type PosLine = {
+    id: string;
+    price: string;
+    quantity: string;
+    rate: string;
+    discount?: PosDiscount;
+};
+/** The point-of-sale panel's state. Strings only, never persisted. */
+export type PosState = {
+    lines: PosLine[];
+    discount?: PosDiscount;
+    field: PosField;
+    /** What is being typed: minor units, a count, or a whole percent. */
+    price: string;
+    quantity: string;
+    /** The next digit starts a new quantity instead of extending the old one. */
+    fresh: boolean;
+    entry: string;
+    kind: DiscountKind;
+    tendered: string;
+    rate: string;
+    /** `null`: follow the `pricesIncludeVat` prop. */
+    inclusive: boolean | null;
+    next: number;
+};
+export declare const INITIAL_POS: PosState;
+/** What the props tell the panel; the reducer needs no more. */
+export type PosEnv = {
+    /** ISO 4217 code, when the application names one. */
+    currency?: string;
+    digits: number;
+    rates: readonly string[];
+    inclusive: boolean;
+};
+export type PosAction = {
+    type: 'key';
+    key: CalcKey;
+} | {
+    type: 'field';
+    field: PosField;
+} | {
+    type: 'kind';
+    kind: DiscountKind;
+} | {
+    type: 'rate';
+    rate: string;
+} | {
+    type: 'inclusive';
+    on: boolean;
+} | {
+    type: 'remove';
+    id: string;
+} | {
+    type: 'remove-discount';
+} | {
+    type: 'tender';
+    amount: string;
+} | {
+    type: 'reset';
+}
+/** The ticket was charged: the same reset, announced. */
+ | {
+    type: 'charged';
+};
+export declare const isInclusive: (s: PosState, env: PosEnv) => boolean;
+/** The VAT rate a new line takes: the chosen one, else the first, else none. */
+export declare const rateOf: (s: PosState, env: PosEnv) => string;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-variant.d.ts

@@ -0,0 +1,3 @@
+import { VariantModule } from '../variant-loader.js';
+/** The point-of-sale variant as one on-demand chunk: its panels and ticket maths. */
+export declare const variant: VariantModule;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-vat.d.ts

@@ -0,0 +1,2 @@
+/** The VAT rate a new line takes, and whether the prices typed include it. */
+export declare function PosVat(): import("react").JSX.Element | null;

package/dist/lib/components/ui/widgets/calculator/variants/pos/pos-view.d.ts

@@ -0,0 +1,28 @@
+import { Decimal } from '@nxgt/material-core/calculator';
+import { Settlement, Ticket, Totals } from '@nxgt/material-core/calculator/pos';
+import { PosTicket } from './pos-ticket-data.js';
+import { PosEnv, PosState } from './pos-types.js';
+export type PosView = {
+    /** What `onCharge` receives. */
+    ticket: PosTicket;
+    totals: Totals;
+    /** Set once something was tendered. */
+    settlement: Settlement | null;
+    /** The exact total, then round bills at or above it (at most four). */
+    shortcuts: readonly Decimal[];
+    /** An amount in the locale, with the currency's decimals. */
+    money: (amount: Decimal) => string;
+    /** An amount with the currency's code after it, for the live region and the Charge button. */
+    withCode: (amount: Decimal) => string;
+    /** A plain number in the locale (a VAT rate: `5,5` in French). */
+    number: (value: Decimal) => string;
+    /** The total as plain text with the currency's decimals (`'12.50'`). */
+    total: string;
+    canCharge: boolean;
+};
+/** The core ticket for the state: the lines and discount, validated by the engine. */
+export declare function buildTicket(s: PosState, digits: number): Ticket;
+/** Everything the panel shows, computed by the engine from the state. */
+export declare function selectPos(s: PosState, env: PosEnv, denominations: readonly string[], locale?: string): PosView;
+/** The field being typed, as it is drawn on the display. */
+export declare function entryText(s: PosState, env: PosEnv, view: PosView): string;

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-announce.d.ts

@@ -0,0 +1,19 @@
+import { CalcSession } from '@nxgt/material-core/calculator';
+import { Base } from '@nxgt/material-core/calculator/programmer';
+import { Announcement } from '../../calculator-announce.js';
+import { ProgrammerState } from './programmer-state.js';
+/**
+ * The result announcement of a Programmer `=`, with the value in the base
+ * being typed (`FF`, not `255`); every other announcement, and the other
+ * variants', pass through.
+ */
+export declare function programmerResult(said: Announcement | null, next: CalcSession, p: ProgrammerState | undefined): Announcement | null;
+declare const BASE_NAME: {
+    readonly 16: readonly ["material.calculator.programmer.hex", "Hexadecimal"];
+    readonly 10: readonly ["material.calculator.programmer.dec", "Decimal"];
+    readonly 8: readonly ["material.calculator.programmer.oct", "Octal"];
+    readonly 2: readonly ["material.calculator.programmer.bin", "Binary"];
+};
+/** A press on a digit the base does not have: it says so instead of staying silent. */
+export declare function unavailableDigit(base: Base, t: (key: (typeof BASE_NAME)[Base][0], fallback: string) => string): Announcement;
+export {};

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-base.d.ts

@@ -0,0 +1,11 @@
+import { CalcSession } from '@nxgt/material-core/calculator';
+import { Base } from '@nxgt/material-core/calculator/programmer';
+import { ProgrammerStep } from './programmer-reduce.js';
+import { ProgrammerState } from './programmer-state.js';
+/**
+ * A new base. A calculable number follows into it (an expression collapses to
+ * its value, and says so); one that does not calculate yet (`(10`) has each
+ * literal rewritten in place, and a base change that cannot be done cleanly
+ * is refused.
+ */
+export declare function changeBase(session: CalcSession, p: ProgrammerState, base: Base, value: bigint | undefined): ProgrammerStep;

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-bitpad.d.ts

@@ -0,0 +1,14 @@
+import { ProgrammerState } from './programmer-state.js';
+type Props = {
+    /** The word's value; `undefined` while the expression does not calculate (the pad is inert). */
+    value: bigint | undefined;
+    programmer: ProgrammerState;
+    onToggle: (index: number) => void;
+};
+/**
+ * One button per bit of the word, most significant first, grouped by four. A
+ * disclosure keeps the pad out of the way until it is wanted: sixty-four
+ * 44px targets are most of a phone screen.
+ */
+export declare function ProgrammerBitpad({ value, programmer, onToggle }: Props): import("react").JSX.Element;
+export {};

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-display.d.ts

@@ -0,0 +1,9 @@
+import { DisplayModel } from '../../calculator.selectors.js';
+import { CalculatorState } from '../../calculator.slice.js';
+import { EngineSettings } from '../../engine.js';
+/**
+ * The display of the Programmer variant: the value in the base the keys type
+ * in (upper case, grouped), not in the locale's decimal. `value` stays the
+ * exact decimal text, which is what Copy writes.
+ */
+export declare function selectProgrammerDisplay(state: CalculatorState, settings: EngineSettings): DisplayModel;

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-layout.d.ts

@@ -0,0 +1,6 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+import { KeyLayout } from '../key-layout.js';
+/** Digits, then the arithmetic keys: C ± mod ÷ over the digits, and `0 ⌫ =` last. */
+export declare const PROGRAMMER_LAYOUT: KeyLayout;
+/** Keys the physical keyboard takes beyond the keypad's. */
+export declare const PROGRAMMER_EXTRA_KEYS: readonly CalcKey[];

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-names.d.ts

@@ -0,0 +1,2 @@
+/** The spoken names of the Programmer keys: `material.calculator.keys.<name>`. */
+export declare const PROGRAMMER_NAMES: readonly ["hex-a", "hex-b", "hex-c", "hex-d", "hex-e", "hex-f", "and", "or", "xor", "not", "nand", "nor", "shift-left", "shift-right", "rotate-left", "rotate-right"];

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-readouts.d.ts

@@ -0,0 +1,14 @@
+import { Base } from '@nxgt/material-core/calculator/programmer';
+import { ProgrammerState } from './programmer-state.js';
+type Props = {
+    value: bigint;
+    programmer: ProgrammerState;
+    onBase: (base: Base) => void;
+};
+/**
+ * The value in the four bases, as a single choice: the one chosen is the base
+ * the digit keys type in. Native radios (arrows move and choose), each read as
+ * its base's name followed by the value.
+ */
+export declare function ProgrammerReadouts({ value, programmer, onBase }: Props): import("react").JSX.Element;
+export {};