calcsuite-react 1.0.0

package/dist/core/calculators/deposits.d.ts

@@ -0,0 +1,2 @@
+import type { CalculatorDef } from '../kit';
+export declare const depositCalculators: CalculatorDef[];

package/dist/core/calculators/investments.d.ts

@@ -0,0 +1,2 @@
+import type { CalculatorDef } from '../kit';
+export declare const investmentCalculators: CalculatorDef[];

package/dist/core/calculators/loans.d.ts

@@ -0,0 +1,2 @@
+import { type CalculatorDef } from '../kit';
+export declare const loanCalculators: CalculatorDef[];

package/dist/core/calculators/retirement_us.d.ts

@@ -0,0 +1,2 @@
+import type { CalculatorDef } from '../kit';
+export declare const usRetirementCalculators: CalculatorDef[];

package/dist/core/calculators/returns.d.ts

@@ -0,0 +1,2 @@
+import type { CalculatorDef } from '../kit';
+export declare const returnsCalculators: CalculatorDef[];

package/dist/core/calculators/scientific.d.ts

@@ -0,0 +1,2 @@
+import type { CalculatorDef } from '../kit';
+export declare const sciCalculators: CalculatorDef[];

package/dist/core/calculators/tax.d.ts

@@ -0,0 +1,2 @@
+import type { CalculatorDef } from '../kit';
+export declare const taxCalculators: CalculatorDef[];

package/dist/core/calculators/utility.d.ts

@@ -0,0 +1,2 @@
+import type { CalculatorDef } from '../kit';
+export declare const utilityCalculators: CalculatorDef[];

package/dist/core/currency.d.ts

@@ -0,0 +1,20 @@
+import { type DecimalT, type Numeric } from './decimal';
+export interface CurrencyMeta {
+    code: string;
+    name: string;
+    symbol: string;
+}
+export declare const CURRENCIES: CurrencyMeta[];
+export declare const currencyByCode: (code: string) => CurrencyMeta | undefined;
+/** amount × rate, exact. */
+export declare const convert: (amount: Numeric, rate: Numeric) => DecimalT;
+/** 1 unit of target buys this many of source. 0 when the rate is not positive. */
+export declare const inverseRate: (rate: Numeric) => DecimalT;
+/** Format a Decimal amount as its currency, using ISO 4217 decimals + symbol. */
+export declare function formatCurrency(amount: Numeric, code: string): string;
+/** How many fraction digits the currency uses (JPY 0, KWD 3, most 2). */
+export declare function currencyDecimals(code: string): number;
+/** Human "how stale" label for an offline saved rate. */
+export declare function stalenessLabel(atMs: number, nowMs: number): string;
+/** A saved offline rate is "stale" once it is older than a day. */
+export declare const isStale: (atMs: number, nowMs: number) => boolean;

package/dist/core/decimal.d.ts

@@ -0,0 +1,9 @@
+import DecimalBase from 'decimal.js';
+export declare const Decimal: typeof DecimalBase;
+export type DecimalT = InstanceType<typeof Decimal>;
+export type Numeric = string | number | DecimalT;
+export declare const D: (v: Numeric) => DecimalT;
+export declare const eq: (a: Numeric, b: Numeric) => boolean;
+export declare const gt: (a: Numeric, b: Numeric) => boolean;
+export declare const lt: (a: Numeric, b: Numeric) => boolean;
+export declare const isZeroish: (d: DecimalT, epsilon?: string) => boolean;

package/dist/core/finance.d.ts

@@ -0,0 +1,30 @@
+import { type DecimalT, type Numeric } from './decimal';
+export declare const periodic: (annualPct: Numeric, perYear?: number) => DecimalT;
+/** Future value of a level annuity of PMT per period at rate r for n periods. */
+export declare function fvAnnuity(PMT: Numeric, r: Numeric, n: number, due?: boolean): DecimalT;
+/** Future value of a single lump sum. */
+export declare function fvLump(PV: Numeric, r: Numeric, n: number): DecimalT;
+/** Present value of a level annuity. */
+export declare function pvAnnuity(PMT: Numeric, r: Numeric, n: number, due?: boolean): DecimalT;
+/** Present value of a single future amount. */
+export declare function pvLump(FV: Numeric, r: Numeric, n: number): DecimalT;
+/** Level payment that amortises PV to FV over n periods. */
+export declare function pmt(PV: Numeric, r: Numeric, n: number, FV?: Numeric, due?: boolean): DecimalT;
+/** Number of periods to amortise PV at PMT and rate r. */
+export declare function nper(PV: Numeric, PMT: Numeric, r: Numeric): DecimalT;
+/** Generic monotonic-in-rate bisection: find rate in [lo,hi] where f(rate)=0. */
+export declare function bisectRate(f: (r: DecimalT) => DecimalT, lo?: number, hi?: number, iters?: number): DecimalT | null;
+/** NPV of periodic cashflows (cf[0] at t=0). */
+export declare function npv(rate: Numeric, cashflows: Numeric[]): DecimalT;
+/** IRR of periodic cashflows via bracketed bisection. Returns a fraction (0.1 = 10%). */
+export declare function irr(cashflows: Numeric[]): DecimalT | null;
+export interface DatedFlow {
+    date: string;
+    amount: Numeric;
+}
+/** XNPV: net present value of irregular dated cashflows, ACT/365. */
+export declare function xnpv(rate: Numeric, flows: DatedFlow[]): DecimalT;
+/** XIRR: annualised return of irregular dated cashflows. Fraction (0.12 = 12%). */
+export declare function xirr(flows: DatedFlow[]): DecimalT | null;
+/** CAGR from begin/end value over years. Fraction. */
+export declare function cagr(begin: Numeric, end: Numeric, years: Numeric): DecimalT;

package/dist/core/format.d.ts

@@ -0,0 +1,16 @@
+import { type DecimalT, type Numeric } from './decimal';
+import type { Settings } from '../settings/settings';
+export interface Formatter {
+    settings: Settings;
+    money(v: Numeric, places?: number): string;
+    moneyParts(v: Numeric, places?: number): {
+        symbol: string;
+        digits: string;
+    };
+    num(v: Numeric, places?: number): string;
+    pct(v: Numeric, places?: number): string;
+    compact(v: Numeric): string;
+    round(v: Numeric, places?: number): DecimalT;
+}
+export declare function makeFormatter(s: Settings): Formatter;
+export declare function tenureText(months: number): string;

package/dist/core/kit.d.ts

@@ -0,0 +1,109 @@
+import type { ReactNode } from 'react';
+import { type DecimalT, type Numeric } from './decimal';
+import type { Formatter } from './format';
+import type { Settings, Region } from '../settings/settings';
+export type Group = 'loans' | 'invest' | 'returns' | 'tax' | 'tools';
+export type FieldKind = 'money' | 'percent' | 'int' | 'number' | 'tenure' | 'years' | 'select' | 'segmented' | 'date' | 'toggle' | 'text' | 'cashflows';
+export type FieldValue = string | number | boolean | Array<{
+    date: string;
+    amount: string;
+}>;
+export type Values = Record<string, FieldValue>;
+export interface FieldSchema {
+    key: string;
+    label: string;
+    kind: FieldKind;
+    default?: FieldValue;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    min?: number;
+    max?: number;
+    step?: number;
+    suffix?: string;
+    prefix?: 'currency' | string;
+    help?: string;
+    optional?: boolean;
+    advanced?: boolean;
+    showIf?: (v: Values, region: Region) => boolean;
+    /** Region-specific label override, e.g. 'EMI' vs 'Monthly payment'. */
+    labelByRegion?: Partial<Record<Region, string>>;
+}
+export type MetricTone = 'default' | 'principal' | 'interest' | 'accent' | 'positive' | 'negative';
+export interface Metric {
+    label: string;
+    value: string;
+    tone?: MetricTone;
+    sub?: string;
+}
+export interface ScheduleRow {
+    label: string;
+    cells: string[];
+}
+export interface ScheduleGroup {
+    label: string;
+    summary: string[];
+    rows: ScheduleRow[];
+}
+export interface ScheduleView {
+    title?: string;
+    columns: string[];
+    groups?: ScheduleGroup[];
+    rows?: ScheduleRow[];
+    /** column index → semantic tone for cell colouring */
+    toneCols?: Record<number, 'principal' | 'interest'>;
+}
+export interface ChartSeries {
+    labels?: string[];
+    series: Array<{
+        name: string;
+        tone: 'principal' | 'interest' | 'accent';
+        points: number[];
+        area?: boolean;
+        dash?: boolean;
+    }>;
+}
+export interface ResultView {
+    primary: Metric;
+    primaryPer?: string;
+    secondary?: Metric[];
+    split?: Array<{
+        label: string;
+        value: number;
+        tone: 'principal' | 'interest' | 'accent';
+    }>;
+    schedule?: ScheduleView;
+    chart?: ChartSeries;
+    formula?: string;
+    formulaSubstituted?: string;
+    notes?: string[];
+    warnings?: string[];
+    /** raw values for export/save; strings to stay float-safe */
+    raw?: Record<string, string | number | null>;
+}
+export interface CalcCtx {
+    settings: Settings;
+    region: Region;
+    fmt: Formatter;
+    D: (v: Numeric) => DecimalT;
+}
+export interface CalculatorDef {
+    id: string;
+    group: Group;
+    title: string;
+    blurb?: string;
+    keywords?: string[];
+    regions?: Region[];
+    icon?: ReactNode;
+    inputs: FieldSchema[];
+    compute: (values: Values, ctx: CalcCtx) => ResultView;
+    /** Optional bespoke panel (scientific calculator, EMI solve-for chips, etc.). */
+    custom?: string;
+}
+export declare const numval: (v: FieldValue | undefined, fallback?: number) => number;
+export declare const strval: (v: FieldValue | undefined, fallback?: string) => string;
+export declare const boolval: (v: FieldValue | undefined, fallback?: boolean) => boolean;
+/** Decimal money value cleaned of grouping — never lose precision. */
+export declare const dmoney: (v: FieldValue | undefined, fallback?: string) => DecimalT;
+export declare const metric: (label: string, value: string, tone?: MetricTone, sub?: string) => Metric;

package/dist/core/liveRates.d.ts

@@ -0,0 +1,11 @@
+export interface LiveRateResult {
+    rate: string;
+    asOf: string;
+    provider: string;
+}
+export declare function fetchLiveRate(from: string, to: string, opts?: {
+    fetchImpl?: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<LiveRateResult>;
+/** Parse the provider's UTC timestamp to epoch ms; falls back to `nowMs`. */
+export declare function asOfMs(asOf: string, nowMs: number): number;

package/dist/core/loan.d.ts

@@ -0,0 +1,70 @@
+import { type DecimalT, type Numeric } from './decimal';
+export type Region = 'IN' | 'US';
+export type Basis = 'reducing_monthly' | 'flat';
+export type SolveTarget = 'payment' | 'principal' | 'rate' | 'tenure';
+export interface RegionProfile {
+    region: Region;
+    currency: 'INR' | 'USD';
+    locale: string;
+    paymentLabel: string;
+    tenureWord: string;
+    feeWord: string;
+    grouping: 'indian' | 'western';
+    defaultBasis: Basis;
+    defaultRatePct: string;
+    defaultTermMonths: number;
+    maxRatePct: number;
+}
+export declare const REGIONS: Record<Region, RegionProfile>;
+export type ErrorCode = 'MISSING_SOLVE_TARGET' | 'MULTIPLE_SOLVE_TARGETS' | 'PAYMENT_BELOW_INTEREST' | 'RATE_OUT_OF_RANGE' | 'TENURE_OUT_OF_RANGE' | 'NEGATIVE_PRINCIPAL' | 'SOLVER_DID_NOT_CONVERGE';
+export declare class FinCalcError extends Error {
+    code: ErrorCode;
+    field?: string;
+    constructor(code: ErrorCode, message: string, field?: string);
+}
+export interface LoanInput {
+    region: Region;
+    basis?: Basis;
+    principal?: Numeric;
+    annualRatePct?: Numeric;
+    tenureMonths?: number;
+    payment?: Numeric;
+}
+export interface AmortRow {
+    month: number;
+    openingBalance: DecimalT;
+    payment: DecimalT;
+    principal: DecimalT;
+    interest: DecimalT;
+    closingBalance: DecimalT;
+    cumulativeInterest: DecimalT;
+}
+export interface YearSummary {
+    year: number;
+    months: AmortRow[];
+    principal: DecimalT;
+    interest: DecimalT;
+    payment: DecimalT;
+    closingBalance: DecimalT;
+}
+export interface LoanResult {
+    solvedFor: SolveTarget;
+    basis: Basis;
+    region: Region;
+    principal: DecimalT;
+    annualRatePct: DecimalT;
+    tenureMonths: number;
+    payment: DecimalT;
+    totalInterest: DecimalT;
+    totalPayment: DecimalT;
+    schedule: AmortRow[];
+    byYear: YearSummary[];
+    chart: {
+        balance: DecimalT[];
+        cumulativeInterest: DecimalT[];
+    };
+    /** Flat-rate loans only: the equivalent reducing-balance rate (§4.5). */
+    equivalentReducingRatePct?: DecimalT;
+    formula: string;
+}
+export declare function solve(input: LoanInput): LoanResult;

package/dist/core/registry.d.ts

@@ -0,0 +1,10 @@
+import type { CalculatorDef, Group } from './kit';
+import type { Region } from '../settings/settings';
+export declare function registerCalculator(def: CalculatorDef): void;
+export declare function allCalculators(): CalculatorDef[];
+export declare function calculatorsForRegion(region: Region): CalculatorDef[];
+export declare function calculatorById(id: string): CalculatorDef | undefined;
+export declare const GROUPS: Array<{
+    id: Group;
+    label: string;
+}>;

package/dist/core/sci/evaluator.d.ts

@@ -0,0 +1,14 @@
+import { type DecimalT } from '../decimal';
+import type { Node } from './parser';
+import type { Base } from './tokenizer';
+export type AngleMode = 'deg' | 'rad' | 'grad';
+export type PercentMode = 'of' | 'modulo';
+export interface EvalOpts {
+    angleMode?: AngleMode;
+    percentMode?: PercentMode;
+    ans?: DecimalT | string | number;
+    memory?: DecimalT | string | number;
+    vars?: Record<string, DecimalT | string | number>;
+    base?: Base;
+}
+export declare function evaluate(ast: Node, opts?: EvalOpts): DecimalT;

package/dist/core/sci/index.d.ts

@@ -0,0 +1,22 @@
+import { type DecimalT } from '../decimal';
+import { type Base } from './tokenizer';
+import { type AngleMode, type PercentMode } from './evaluator';
+export { tokenize } from './tokenizer';
+export { parse } from './parser';
+export { evaluate } from './evaluator';
+export type { Node } from './parser';
+export type { Token, Base } from './tokenizer';
+export type { AngleMode, PercentMode, EvalOpts } from './evaluator';
+export interface EvalExprOpts {
+    angleMode?: AngleMode;
+    percentMode?: PercentMode;
+    ans?: DecimalT | string | number;
+    memory?: DecimalT | string | number;
+    vars?: Record<string, DecimalT | string | number>;
+    base?: Base;
+}
+export interface EvalResult {
+    value: DecimalT;
+    error?: string;
+}
+export declare function evalExpression(input: string, opts?: EvalExprOpts): EvalResult;

package/dist/core/sci/parser.d.ts

@@ -0,0 +1,32 @@
+import type { Token } from './tokenizer';
+export type Node = {
+    type: 'num';
+    value: string;
+} | {
+    type: 'const';
+    name: string;
+} | {
+    type: 'var';
+    name: string;
+} | {
+    type: 'unary';
+    op: string;
+    operand: Node;
+} | {
+    type: 'binary';
+    op: string;
+    left: Node;
+    right: Node;
+} | {
+    type: 'postfix';
+    op: string;
+    operand: Node;
+} | {
+    type: 'percent';
+    operand: Node;
+} | {
+    type: 'call';
+    name: string;
+    args: Node[];
+};
+export declare function parse(tokens: Token[]): Node;

package/dist/core/sci/tokenizer.d.ts

@@ -0,0 +1,10 @@
+export type Base = 'DEC' | 'HEX' | 'OCT' | 'BIN';
+export type TokenType = 'num' | 'func' | 'const' | 'var' | 'op' | 'uop' | 'postfix' | 'lparen' | 'rparen' | 'comma';
+export interface Token {
+    type: TokenType;
+    value: string;
+    implicit?: boolean;
+}
+export declare function tokenize(input: string, opts?: {
+    base?: Base;
+}): Token[];

package/dist/export/index.d.ts

@@ -0,0 +1,56 @@
+import type { ResultView, Values } from '../core/kit';
+import type { Region, Settings } from '../settings/settings';
+export declare const SCHEMA_VERSION = 1;
+export type ExportFormat = 'csv' | 'tsv' | 'json' | 'url' | 'clipboard' | 'markdown' | 'print' | 'ics' | 'pdf' | 'xlsx' | 'png' | 'qr';
+export interface ExportPayload {
+    calculatorId: string;
+    title: string;
+    result: ResultView;
+    values: Values;
+    settingsSnapshot: Settings;
+    meta: {
+        computedAt: string;
+        region: Region;
+        currency: string;
+    };
+}
+export interface ExportResult {
+    ok: boolean;
+    note?: string;
+    filename?: string;
+    data?: string;
+}
+export interface ExportOptions {
+    scale?: 1 | 2 | 3;
+    schemaVersion?: number;
+}
+export declare const EXPORT_FORMATS: Array<{
+    id: ExportFormat;
+    label: string;
+}>;
+/** No path separators, no leading dots, no control/reserved chars. */
+export declare function sanitizeFilename(name: string): string;
+/** filenameTemplate '{calculator}-{yyyy}{MM}{dd}.{ext}' */
+export declare function buildFilename(p: ExportPayload, ext: string): string;
+/** Trigger a browser download for a Blob or string. */
+export declare function download(filename: string, data: Blob | string, mime?: string): void;
+export declare function toCsv(p: ExportPayload): string;
+export declare function toTsv(p: ExportPayload): string;
+export declare function toJson(p: ExportPayload, schemaVersion?: number): string;
+export declare function importJson(text: string): {
+    calculatorId: string;
+    values: Values;
+};
+/** '#fincalc=<id>&s=<base64url({id,values})>'. base64url so URLSearchParams is safe. */
+export declare function buildShareHash(id: string, values: Values): string;
+export declare function parseShareUrl(hash: string): {
+    id: string;
+    values: Values;
+} | null;
+export declare function toMarkdown(p: ExportPayload): string;
+export declare function toIcs(p: ExportPayload): string;
+export declare function createExporter(opts?: ExportOptions): {
+    formats: ExportFormat[];
+    export(format: ExportFormat, payload: ExportPayload, options?: ExportOptions): Promise<ExportResult>;
+};
+export type Exporter = ReturnType<typeof createExporter>;

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+export { SettingsProvider, SettingsProvider as FinCalcProvider, useSettings, useSettings as useFinCalc } from './settings/SettingsContext';
+export { DEFAULT_SETTINGS, regionDefaults, POLICY_DEFAULT } from './settings/settings';
+export type { Settings, Settings as FinCalcSettings, Region, RoundingPolicy, RoundingMode, DayCountConvention, Grouping, } from './settings/settings';
+export { Launcher, Launcher as FinCalcLauncher } from './ui/Launcher';
+export type { LauncherProps, LauncherApi } from './ui/Launcher';
+export { Shell, Shell as FinCalcRoot } from './ui/Shell';
+export { Dialog, Dialog as FinCalcDialog } from './ui/Dialog';
+export { CommandPalette } from './ui/CommandPalette';
+export { CalculatorPanel } from './ui/CalculatorPanel';
+export { LoanEmiPanel } from './ui/LoanEmiPanel';
+export { SciCalculator } from './ui/SciCalculator';
+export { CurrencyConverter } from './ui/CurrencyConverter';
+export { SettingsPanel } from './ui/SettingsPanel';
+export { HistoryPanel } from './ui/HistoryPanel';
+export { ResultCard } from './ui/ResultCard';
+export { ScheduleTable } from './ui/ScheduleTable';
+export { Chart } from './ui/Chart';
+export { Field } from './ui/fields';
+export { SaveButton } from './ui/SaveButton';
+export { ExportMenu } from './ui/ExportMenu';
+export { IntegrationPanel } from './ui/IntegrationPanel';
+export { useHistory, saveHistory, clearHistory } from './ui/history';
+export type { HistoryItem } from './ui/history';
+export { registerCalculator, allCalculators, calculatorsForRegion, calculatorById, GROUPS } from './core/registry';
+export { metric, numval, strval, boolval, dmoney } from './core/kit';
+export type { CalculatorDef, FieldSchema, FieldKind, FieldValue, Values, ResultView, Metric, ScheduleView, ScheduleGroup, ScheduleRow, ChartSeries, CalcCtx, Group, } from './core/kit';
+import { solve } from './core/loan';
+/** Loan / EMI engine. `loan.solve({ region, product?, principal, annualRatePct, tenureMonths })`. */
+export declare const loan: {
+    solve: typeof solve;
+    REGIONS: Record<import("./core/loan").Region, import(".").RegionProfile>;
+};
+export { solve as solveLoan } from './core/loan';
+export type { LoanInput, LoanResult, RegionProfile, Basis, SolveTarget, AmortRow, YearSummary } from './core/loan';
+export { FinCalcError } from './core/loan';
+export * as finance from './core/finance';
+export * as currency from './core/currency';
+export { fetchLiveRate } from './core/liveRates';
+export { makeFormatter } from './core/format';
+export type { Formatter } from './core/format';
+export { Decimal, D, eq, gt, lt, isZeroish } from './core/decimal';
+export type { DecimalT, Numeric } from './core/decimal';
+export { evalExpression, parse as parseExpression, evaluate as evaluateExpression } from './core/sci';
+export { createExporter, EXPORT_FORMATS } from './export';
+export type { ExportPayload, ExportFormat } from './export';
+export { createTransport, sanitizeFilename, buildFilename } from './transport/client';
+export { buildPayload, buildSavePayload, DEFAULT_ENVELOPE } from './transport/payload';
+export { createFxCache } from './transport/fx';
+export type { TransportConfig, UploadConfig, PayloadField } from './transport/types';

package/dist/settings/SettingsContext.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from 'react';
+import { type Region, type Settings } from './settings';
+import { type Formatter } from '../core/format';
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+interface SettingsCtx {
+    settings: Settings;
+    fmt: Formatter;
+    update: (patch: DeepPartial<Settings>) => void;
+    setRegion: (r: Region) => void;
+    reset: () => void;
+    replace: (s: Settings) => void;
+    resolvedTheme: 'light' | 'dark' | 'highContrast';
+}
+export declare function SettingsProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useSettings(): SettingsCtx;
+export {};

package/dist/settings/settings.d.ts

@@ -0,0 +1,72 @@
+export type Region = 'IN' | 'US';
+export type RoundingMode = 'HALF_UP' | 'HALF_EVEN' | 'HALF_DOWN' | 'UP' | 'DOWN' | 'CEIL' | 'FLOOR';
+export type DayCountConvention = '30/360' | 'ACT/365' | 'ACT/360' | 'ACT/ACT' | '30E/360';
+export type Grouping = 'indian' | 'western' | 'european' | 'swiss' | 'plain';
+export interface RoundingPolicy {
+    money: number;
+    rate: number;
+    period: number;
+    mode: RoundingMode;
+    roundEachPeriod: boolean;
+    instalment: 'none' | 'ceilToUnit' | 'roundToUnit';
+    residualAbsorption: 'first' | 'last' | 'spread';
+}
+export interface Settings {
+    region: Region;
+    locale: string;
+    currency: {
+        code: string;
+        symbol: string;
+        symbolPosition: 'prefix' | 'suffix';
+        spaceAfterSymbol: boolean;
+    };
+    numberFormat: {
+        grouping: Grouping;
+        decimalPlaces: 0 | 1 | 2 | 3 | 4;
+        trimTrailingZeros: boolean;
+        abbreviate: boolean;
+        abbreviationScale: 'indian' | 'western';
+        abbreviateThreshold: number;
+        negativeFormat: 'minus' | 'parentheses';
+        percentPlaces: 0 | 1 | 2 | 3 | 4;
+    };
+    rounding: RoundingPolicy;
+    dayCount: DayCountConvention;
+    fiscalYearStart: {
+        month: number;
+        day: number;
+    };
+    ui: {
+        theme: 'light' | 'dark' | 'system' | 'highContrast';
+        accent: string;
+        fontFamily: string;
+        density: 'comfortable' | 'compact';
+        radius: 'sharp' | 'soft' | 'round';
+        showFormulas: boolean;
+        showAssumptions: boolean;
+        reducedMotion: 'system' | 'always' | 'never';
+    };
+    defaults: {
+        tenureUnit: 'years' | 'months' | 'both';
+        rateType: 'fixed' | 'floating';
+        maxRatePercent: number;
+        sipReturnPercent: string;
+        inflationPercent: string;
+    };
+    compliance: {
+        showDisclaimer: boolean;
+        disclaimerText?: string;
+    };
+    persistence: {
+        driver: 'none' | 'localStorage';
+        namespace: string;
+        historyLimit: number;
+    };
+    features: {
+        integrationPanel: boolean;
+        beta: boolean;
+    };
+}
+export declare const POLICY_DEFAULT: RoundingPolicy;
+export declare function regionDefaults(region: Region): Settings;
+export declare const DEFAULT_SETTINGS: Settings;

package/dist/transport/client.d.ts

@@ -0,0 +1,54 @@
+import { type TransportConfig, type UploadMeta } from './types';
+/** Sanitise a filename: no path separators, no leading dots, no control chars. */
+export declare function sanitizeFilename(name: string): string;
+/** Fill a filenameTemplate then sanitise the result. */
+export declare function buildFilename(template: string, meta: UploadMeta): string;
+/** Mask auth-ish header values so nothing secret reaches a log or error. */
+export declare function redactHeaders(headers: Record<string, string>, extraKeys?: string[]): Record<string, string>;
+export interface QueueItem {
+    id: string;
+    endpoint: string;
+    method: string;
+    url: string;
+    body: unknown;
+    headers: Record<string, string>;
+    createdAt: string;
+    retryCount: number;
+    lastError?: string;
+}
+export interface CallOptions {
+    headers?: Record<string, string>;
+    query?: Record<string, string | number | undefined | null>;
+    pathParam?: string;
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+export interface QueuedResult {
+    queued: true;
+    id: string;
+}
+export type Transport = ReturnType<typeof createTransport>;
+export declare function createTransport(config: TransportConfig): {
+    save: <T = unknown>(body: unknown, opts?: CallOptions) => Promise<QueuedResult | T>;
+    update: <T = unknown>(id: string, body: unknown, opts?: CallOptions) => Promise<QueuedResult | T>;
+    get: <T = unknown>(id: string, opts?: CallOptions) => Promise<QueuedResult | T>;
+    list: <T = unknown>(query?: CallOptions["query"], opts?: CallOptions) => Promise<QueuedResult | T>;
+    delete: <T = unknown>(id: string, opts?: CallOptions) => Promise<QueuedResult | T>;
+    upload: (file: Blob, meta: UploadMeta, opts?: CallOptions) => Promise<unknown>;
+    getRates: (base: string, symbols: string[], opts?: CallOptions) => Promise<QueuedResult | {
+        base: string;
+        timestamp: string;
+        rates: Record<string, string>;
+    }>;
+    /** Offline queue inspector — flush re-sends with freshly-resolved auth. */
+    queue: {
+        list: () => QueueItem[];
+        size: () => number;
+        clear: () => void;
+        remove: (id: string) => void;
+        flush: () => Promise<{
+            flushed: number;
+            failed: number;
+        }>;
+    };
+};