@open-slot-ui/core 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,1813 @@
+/**
+ * Zero-dependency reactive primitives — the "M" substrate.
+ * Deliberately tiny: a value box you can subscribe to, plus an effect helper.
+ * No framework, no global graph, no magic. This is the whole reactivity story.
+ */
+type Dispose = () => void;
+interface Subscribable {
+    subscribe(fn: (value: never) => void): Dispose;
+}
+declare class Signal<T> {
+    private _value;
+    private readonly subs;
+    constructor(initial: T);
+    get(): T;
+    set(next: T): void;
+    /** Mutate-in-place then notify (for objects whose identity is stable). */
+    update(mutate: (value: T) => void): void;
+    subscribe(fn: (value: T) => void): Dispose;
+    get size(): number;
+}
+/**
+ * Run `fn` once now and again whenever any dependency changes.
+ * Dependencies are explicit (no auto-tracking) — keeps the model trivial and predictable.
+ */
+declare function effect(fn: () => void, deps: Subscribable[]): Dispose;
+
+/** A typed event map: event name -> payload type. */
+type EventMap = Record<string, unknown>;
+/**
+ * One typed event bus. Period. (Charter B1.)
+ * No magic strings sprinkled around the codebase; payloads are checked.
+ */
+declare class EventBus<E extends EventMap> {
+    private readonly map;
+    on<K extends keyof E>(type: K, fn: (payload: E[K]) => void): Dispose;
+    emit<K extends keyof E>(type: K, payload: E[K]): void;
+}
+
+/** Shared types with no dependencies — safe for everything to import. */
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * The façade's outbound event vocabulary (grows as controls are added).
+ * A `type` (not `interface`) so it satisfies the EventBus `Record` constraint.
+ */
+type OpenUIEvents = {
+    /** The player asked to spin (spin control activated while interactable). */
+    spinRequested: void;
+    /** The player asked to slam-stop / skip the reels (autoplay-engaged tap). */
+    skipRequested: void;
+    /** A control changed state — useful for analytics / e2e logging. */
+    stateChanged: {
+        id: string;
+        from: string;
+        to: string;
+    };
+    /** A generic button was activated. */
+    buttonActivated: {
+        id: string;
+    };
+    /** A slider/value control changed (e.g. sound volume 0..1). */
+    valueChanged: {
+        id: string;
+        value: number;
+    };
+    /** A panel opened or closed. */
+    panelToggled: {
+        id: string;
+        open: boolean;
+    };
+    /** A toggle (e.g. turbo) flipped. `on` = "any mode past the first". */
+    toggled: {
+        id: string;
+        on: boolean;
+    };
+    /** A turbo control changed mode (covers 2-mode AND 3-mode cyclers). */
+    turboChanged: {
+        id: string;
+        mode: string;
+        index: number;
+    };
+    /** A select control chose an option (its own typed event — never overloads valueChanged). */
+    optionSelected: {
+        id: string;
+        value: string;
+        index: number;
+    };
+    /** Autoplay started with a chosen count (Infinity = ∞) + optional RG limits. */
+    autoplayStarted: {
+        count: number;
+        lossLimit?: number;
+        singleWinLimit?: number;
+    };
+    /** Autoplay stopped. */
+    autoplayStopped: void;
+    /** The player began a press-and-hold turbo spin on the spin button. */
+    holdSpinStarted: void;
+    /** The player released the held spin button (stop the turbo loop). */
+    holdSpinStopped: void;
+    /** A control was hidden or shown at runtime (e.g. a responsive breakpoint change). */
+    visibilityChanged: {
+        id: string;
+        hidden: boolean;
+    };
+    /** A buy-feature card was activated. */
+    cardActivated: {
+        id: string;
+    };
+    /** Locale was changed via the façade. */
+    localeChanged: string;
+    /** A reality-check interval elapsed (RTS 13). `minutes` = the configured interval;
+     *  `elapsedMs` = wall-clock since the last check; totals are session aggregates. */
+    realityCheck: {
+        minutes: number;
+        elapsedMs: number;
+        totalStaked: number;
+        totalWon: number;
+    };
+    /** The notice / error modal was shown. */
+    noticeShown: {
+        blocking: boolean;
+    };
+    /** The notice / error modal was dismissed. */
+    noticeDismissed: void;
+};
+/** A serializable snapshot of one control, for the e2e/introspection API. */
+interface ControlSnapshot {
+    id: string;
+    role: string;
+    state: string;
+    interactable: boolean;
+    bounds: Rect | null;
+    animating: boolean;
+}
+
+/**
+ * Theming = data. Semantic tokens with safe fallbacks (Charter P8).
+ * A game theme is a small override map; nothing renders un-themed because
+ * the renderer always has these defaults to fall back on.
+ */
+interface Theme {
+    color: {
+        accent: string;
+        accentText: string;
+        surface: string;
+        surfaceAlt: string;
+        text: string;
+        textDim: string;
+        disabled: string;
+    };
+    radius: {
+        pill: number;
+        card: number;
+    };
+    space: {
+        sm: number;
+        md: number;
+        lg: number;
+    };
+    type: {
+        family: string;
+        size: {
+            sm: number;
+            md: number;
+            lg: number;
+        };
+    };
+    /** Motion durations in ms. */
+    motion: {
+        fast: number;
+        base: number;
+        slow: number;
+    };
+}
+/** Neutral reference theme. The real game theme is built on top of this. */
+declare const defaultTheme: Theme;
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+/** Produce a new theme from the default (or any base) plus an override patch. */
+declare function extendTheme(base: Theme, patch: DeepPartial<Theme>): Theme;
+
+/** Responsive screen model: orientation, a named breakpoint, and a fit scale. */
+type Orientation = 'landscape' | 'portrait';
+/** A named device bucket. Config can target these to restyle per device. */
+type Breakpoint = 'mobile' | 'tablet' | 'desktop';
+interface ScreenState {
+    width: number;
+    height: number;
+    orientation: Orientation;
+    /** Named device bucket, derived from the shorter screen edge (see LayoutConfig). */
+    breakpoint: Breakpoint;
+    /** Multiply reference-px sizes by this to fit the current screen. */
+    scale: number;
+}
+interface LayoutConfig {
+    /** Reference design resolution for landscape / portrait. */
+    refLandscape: [number, number];
+    refPortrait: [number, number];
+    /** Aspect ratio (w/h) below which we switch to the portrait layout. */
+    portraitBelowAspect: number;
+    /**
+     * Breakpoint thresholds on the SHORTER screen edge (px). A phone is "mobile" in
+     * both orientations because its short edge stays small — the right intuition for
+     * "what device is this". `<= mobile` → mobile, `<= tablet` → tablet, else desktop.
+     */
+    breakpoints: {
+        mobile: number;
+        tablet: number;
+    };
+}
+declare const defaultLayoutConfig: LayoutConfig;
+/** Classify the shorter edge into a named device bucket. Pure, total. */
+declare function breakpointFor(width: number, height: number, cfg: LayoutConfig): Breakpoint;
+declare function computeScreen(width: number, height: number, cfg: LayoutConfig): ScreenState;
+
+/** Explicit anchors — no magic numbers buried in components (Charter P9). */
+type Anchor = 'top-left' | 'top-center' | 'top-right' | 'center-left' | 'center' | 'center-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+interface LayoutSpec {
+    anchor: Anchor;
+    /** Offset from the anchor, in reference px (scaled with the screen). */
+    offset?: [number, number];
+    /** Extra scale multiplier on top of the screen's fit scale. */
+    scale?: number;
+    /** Rotation in degrees, clockwise. Default 0. */
+    rotation?: number;
+}
+interface Placement {
+    x: number;
+    y: number;
+    scale: number;
+    /** Rotation in radians (resolved from `LayoutSpec.rotation`, which is degrees). */
+    rotation: number;
+}
+/** Resolve a control's layout against the current screen. Pure math. */
+declare function resolvePlacement(spec: LayoutSpec, screen: ScreenState): Placement;
+
+/**
+ * Transitions are composable OOP descriptors (Charter B6) — pure data, renderer-agnostic.
+ * The renderer interprets the `kind`; the core never animates anything itself.
+ * Some controls turn, some squish, some tick up, some emit particles — all from these.
+ */
+declare class Squish {
+    scale: number;
+    ms: number;
+    readonly kind: "squish";
+    constructor(scale?: number, ms?: number);
+}
+declare class Pulse {
+    scale: number;
+    ms: number;
+    readonly kind: "pulse";
+    constructor(scale?: number, ms?: number);
+}
+declare class Turn {
+    rps: number;
+    loop: boolean;
+    readonly kind: "turn";
+    /** Rotations per second; loops until the state changes. */
+    constructor(rps?: number, loop?: boolean);
+}
+declare class Fade {
+    alpha: number;
+    ms: number;
+    readonly kind: "fade";
+    constructor(alpha?: number, ms?: number);
+}
+declare class Sequence {
+    steps: Transition[];
+    readonly kind: "sequence";
+    constructor(steps: Transition[]);
+}
+declare class Parallel {
+    steps: Transition[];
+    readonly kind: "parallel";
+    constructor(steps: Transition[]);
+}
+type Transition = Squish | Pulse | Turn | Fade | Sequence | Parallel;
+
+/** One state of a control: is it interactable, and what plays on entry. */
+interface StateDef {
+    interactable: boolean;
+    transition?: Transition;
+}
+type StateMap = Record<string, StateDef>;
+interface ControlOptions {
+    id: string;
+    role: string;
+    layout: LayoutSpec;
+}
+/** What a view reports back for introspection. Set by the renderer's view. */
+type ViewInspect = () => {
+    bounds: Rect | null;
+    animating: boolean;
+};
+/**
+ * Base of every control: a finite state machine that is the single source of
+ * truth for look, interactivity, AND tests (Charter P5/P6/P12).
+ * Renderer-agnostic — it knows nothing about Pixi or the DOM.
+ */
+declare abstract class Control {
+    readonly id: string;
+    readonly role: string;
+    layout: LayoutSpec;
+    /** Declared by the subclass: the legal states and their transitions. */
+    abstract readonly states: StateMap;
+    /** Current state name, observable. */
+    readonly state: Signal<string>;
+    /** The renderer sets this so `inspect()` can report bounds/animation. */
+    viewInspect?: ViewInspect;
+    /**
+     * Optional host gate (e.g. a ref-counted input lock). When set, the control is
+     * interactable only if its state allows it AND the gate returns true. Set per
+     * instance — by OpenUI on register — so multiple HUDs on one page never share
+     * lock state. Interactability stays *derived*, never stored (Charter P6).
+     */
+    gate?: () => boolean;
+    protected readonly disposers: Dispose[];
+    private readonly transitionSubs;
+    constructor(opts: ControlOptions, initial: string);
+    get current(): string;
+    /** Derived, never stored (Charter P6). Folds in the optional host gate. */
+    get interactable(): boolean;
+    /** Transition to a new state. Throws on unknown states (illegal states unrepresentable). */
+    setState(to: string): void;
+    /** The renderer subscribes to play the entry transition for each state change. */
+    onTransition(fn: (t: Transition | undefined, to: string, from: string) => void): Dispose;
+    inspect(): {
+        bounds: Rect | null;
+        animating: boolean;
+    };
+    /** Leak-free teardown (Charter P12). */
+    dispose(): void;
+}
+
+/**
+ * The spin control — the vertical-spine exemplar.
+ * A full state machine: each state declares interactability + an entry transition.
+ * The game drives it via the façade (`busy/idle/stop/disable`); the view drives
+ * the transient input states (`hover/pressed`) and calls `activate()` on release.
+ */
+declare class SpinControl extends Control {
+    private readonly bus;
+    readonly states: StateMap;
+    /**
+     * When true, the view arms press-and-hold: holding the spin button fires a
+     * `holdSpinStarted` and the host turbo-spins until release (`holdSpinStopped`).
+     * A quick tap still spins once. Toggleable via the `spin.press` config.
+     */
+    holdToSpin: boolean;
+    /**
+     * Whether tapping mid-spin slam-stops/skips the reels. Stake Engine's
+     * `disabledSlamstop` jurisdiction flag sets this false → the button then LOCKS
+     * (dims, no tap) during a spin instead of skipping. Observable so the view can
+     * re-dim if it flips at runtime (e.g. on `applyJurisdiction`).
+     */
+    readonly allowSlamStop: Signal<boolean>;
+    /**
+     * Whether the keyboard (Space / Enter) can trigger a spin. Stake's
+     * `disabledSpacebar` sets this false (and turns off hold-to-spin). The renderer
+     * reads it; RTS 14D requires a fresh press per cycle (no auto-repeat).
+     */
+    readonly allowKeyboard: Signal<boolean>;
+    /**
+     * Remaining free spins (0 = normal play). Set it > 0 and the spin button switches
+     * to its free-spins face — a big remaining count over an "FS" label — via the view;
+     * back to 0 returns the normal play button. The host drives the loop; this is just
+     * the display. Set with {@link setFreeSpins}.
+     */
+    readonly freeSpins: Signal<number>;
+    constructor(opts: {
+        id?: string;
+        layout: LayoutSpec;
+        holdToSpin?: boolean;
+    }, bus: EventBus<OpenUIEvents>);
+    /**
+     * Derived (Charter P6), with the slam-stop guard folded in: when slam-stop is
+     * disabled, the in-spin `stop`/`auto` affordance is locked — the button can't be
+     * tapped to skip; it just dims.
+     */
+    get interactable(): boolean;
+    busy(): void;
+    idle(): void;
+    stopState(): void;
+    /** Show the autoplay-engaged look (press to stop). */
+    auto(): void;
+    enable(): void;
+    disable(): void;
+    activate(): void;
+    /** View calls this when a press is held past the hold threshold. Returns whether
+     *  hold-to-spin engaged (so the view knows to wait for release). */
+    holdBegin(): boolean;
+    /** View calls this on release after a hold — the host stops the turbo loop. */
+    holdEnd(): void;
+    /** Switch the button to / from its free-spins face. `n > 0` shows "n FS"; `0`
+     *  restores the normal play button. Non-number/negative is clamped to 0 (P11). */
+    setFreeSpins(n: number): void;
+}
+
+/** Currency / crypto descriptor — the code/symbol + how to format it. */
+interface CurrencySpec {
+    /** ISO code or crypto name: "USD", "EUR", "BTC", "mBTC", "SATS". */
+    code: string;
+    /**
+     * The minimal-unit precision — how many fractional digits show after the `.`:
+     * 2 (USD/EUR cents), 0 (JPY/SATS), 5 (mBTC), 8 (BTC). Values are held + rolled as
+     * integer minor units (no float drift). Clamped to 0..8.
+     */
+    decimals: number;
+    /** Symbol for `display: 'symbol'` (e.g. "$", "€", "₿"). */
+    symbol?: string;
+    /** Show the ISO/crypto `code` (default) or the `symbol` (when one is set). */
+    display?: 'code' | 'symbol';
+    /** Affix on the left or right of the number. Default 'suffix'. */
+    position?: 'prefix' | 'suffix';
+    /** Thousands separator char. Default ','. */
+    separator?: string;
+    /** Decimal point char. Default '.'. */
+    decimalChar?: string;
+}
+interface ValueDisplayOptions {
+    id: string;
+    layout: LayoutSpec;
+    currency: CurrencySpec;
+    /** Optional caption ("Balance" / "Bet"). */
+    label?: string;
+    /** Initial value, in major units (e.g. 1234.56). */
+    initial?: number;
+    /** Optional MINIMUM total column width for the rolling counter (integer + fraction).
+     *  `0`/unset = auto: the odometer is sized tightly to the value and grows as it does,
+     *  so the currency symbol hugs the number and large balances never clamp. Set it only
+     *  to reserve a stable, wider odometer. Clamped 0..18. Default 0 (auto). */
+    digits?: number;
+}
+/**
+ * A value display: a number plus a currency/crypto code. Not interactive — the
+ * host sets the value (`ui.balance.set(...)`) and the renderer animates it.
+ * Value is held in major units; `minorUnits` is the integer the counter rolls.
+ */
+declare class ValueDisplay extends Control {
+    readonly states: StateMap;
+    readonly value: Signal<number>;
+    readonly currency: Signal<CurrencySpec>;
+    readonly label?: string;
+    /** Minimum odometer column width (0 = auto: sized tightly to the value, grows as it
+     *  does). Read by the renderer at build time, so set it before mount (or declaratively
+     *  via `controls.{id}.digits`). */
+    digits: number;
+    constructor(opts: ValueDisplayOptions);
+    /** Set the minimum odometer column width (clamped 0..18; 0 = auto). Read by the
+     *  renderer at build time, so set it before mount (or via `controls.{id}.digits`). */
+    setDigits(n: number): void;
+    /** Never-reject: NaN/Infinity/non-number degrade to a no-op, keeping the last
+     *  good value — malformed host data never throws into the render loop (P11). */
+    set(amount: number): void;
+    get(): number;
+    /** Keep the prior spec on malformed input; clamp decimals to 0..8 (P11). */
+    setCurrency(spec: CurrencySpec): void;
+    /** Integer minor units for the counter (no float drift). */
+    get minorUnits(): number;
+}
+
+interface ButtonOptions {
+    id: string;
+    layout: LayoutSpec;
+    /** Optional text label (e.g. "Rules"). */
+    label?: string;
+    /** ARIA-ish role; default 'button'. */
+    role?: string;
+}
+/**
+ * A generic tap button: idle / hover / pressed / disabled, emitting
+ * `buttonActivated` on a valid press-release. Used for settings, rules, close, …
+ */
+declare class ButtonControl extends Control {
+    private readonly bus?;
+    readonly states: StateMap;
+    readonly label?: string;
+    constructor(opts: ButtonOptions, bus?: EventBus<OpenUIEvents> | undefined);
+    enable(): void;
+    disable(): void;
+    /** The view calls this on a valid press-release. */
+    activate(): void;
+}
+
+interface SliderOptions {
+    id: string;
+    layout: LayoutSpec;
+    /** Initial value, 0..1. Default 0.5. */
+    initial?: number;
+    label?: string;
+}
+/**
+ * A 0..1 slider (sound volume, etc.). The view drives `setNormalized` while
+ * dragging; the lib holds the value and emits `valueChanged`. The host applies
+ * the actual effect (e.g. sets audio volume).
+ */
+declare class SliderControl extends Control {
+    private readonly bus?;
+    readonly states: StateMap;
+    readonly value: Signal<number>;
+    readonly label?: string;
+    constructor(opts: SliderOptions, bus?: EventBus<OpenUIEvents> | undefined);
+    /** Set the normalized value (0..1) and notify. */
+    setNormalized(v: number): void;
+    beginDrag(): void;
+    endDrag(): void;
+}
+
+type PanelVariant = 'modal' | 'popover';
+interface PanelOptions {
+    id: string;
+    variant: PanelVariant;
+    layout?: LayoutSpec;
+    /** Title shown at the top of a modal. */
+    title?: string;
+}
+/**
+ * A panel that opens/closes. `modal` = full-screen backdrop + scrollable content
+ * + close button; `popover` = small anchored cluster (e.g. the settings flyout).
+ * State is the single source of truth (open|closed); the view animates it.
+ */
+declare class PanelControl extends Control {
+    private readonly bus?;
+    readonly states: StateMap;
+    readonly variant: PanelVariant;
+    readonly title?: string;
+    constructor(opts: PanelOptions, bus?: EventBus<OpenUIEvents> | undefined);
+    get isOpen(): boolean;
+    openPanel(): void;
+    closePanel(): void;
+    toggle(): void;
+}
+
+interface ToggleOptions {
+    id: string;
+    layout: LayoutSpec;
+    /** Initial on/off. Default false. */
+    on?: boolean;
+}
+/**
+ * An on/off toggle (e.g. Turbo). State IS the value: `off` | `on`. Emits `toggled`.
+ * The view skins each state (e.g. the Turbo off/on frames).
+ */
+declare class ToggleControl extends Control {
+    private readonly bus?;
+    readonly states: StateMap;
+    constructor(opts: ToggleOptions, bus?: EventBus<OpenUIEvents> | undefined);
+    get isOn(): boolean;
+    set(on: boolean): void;
+    /** Called by the view on a valid press-release. */
+    toggle(): void;
+    enable(): void;
+    disable(): void;
+}
+
+interface TurboOptions {
+    id: string;
+    layout: LayoutSpec;
+    /**
+     * The ordered modes this switcher cycles through. The FIRST mode is "off".
+     * Two modes (`['off','on']`) behave exactly like a plain on/off toggle; three
+     * (`['off','turbo','super']`) make a 3-mode switcher. Default `['off','on']`.
+     */
+    modes?: string[];
+    /** Initial mode index. Default 0 (off). */
+    index?: number;
+}
+/**
+ * Turbo switcher. Each press advances to the next mode and wraps back to "off"
+ * — so the SAME control is a 2-mode toggle or a 3-mode (off / turbo / super)
+ * switcher purely by configuration. The current FSM state IS the current mode,
+ * so look + interactivity + tests all read from one place (Charter P5).
+ *
+ * Emits both `turboChanged` (mode + index, the full story) and `toggled`
+ * (`on` = "any mode past off") so existing 2-mode listeners keep working.
+ */
+declare class TurboControl extends Control {
+    private readonly bus?;
+    states: StateMap;
+    private _modes;
+    /** Current mode index, observable (0 = off). */
+    readonly index: Signal<number>;
+    constructor(opts: TurboOptions, bus?: EventBus<OpenUIEvents> | undefined);
+    private static buildStates;
+    /** The ordered modes (the first is "off"). */
+    get modes(): string[];
+    /** Number of modes (2 = toggle, 3 = three-mode switcher). */
+    get modeCount(): number;
+    /** The current mode name. */
+    get mode(): string;
+    /** True for any mode past "off" — the 2-mode `isOn` semantics, preserved. */
+    get isOn(): boolean;
+    /** Replace the mode ladder (e.g. switch a game from 2-mode to 3-mode at runtime). */
+    setModes(modes: string[]): void;
+    /** Advance to the next mode, wrapping back to "off". The view's tap handler. */
+    cycle(): void;
+    /** Jump to a specific mode index (clamped). */
+    setIndex(i: number): void;
+    /** 2-mode convenience: off (index 0) or on (index 1). */
+    set(on: boolean): void;
+    /** Alias kept so old `toggle()` callers compile — same as `cycle()`. */
+    toggle(): void;
+    private goTo;
+    enable(): void;
+    disable(): void;
+}
+
+interface StepperOptions {
+    id: string;
+    layout: LayoutSpec;
+    /** Ordered list of allowed values (e.g. bet levels). */
+    levels: number[];
+    /** Starting index into `levels`. Default 0. */
+    index?: number;
+    /** Optional caption (e.g. "Bet"). */
+    label?: string;
+}
+/**
+ * Steps through a host-provided ordered list of values (bet levels). `inc`/`dec`
+ * move the index and clamp at the ends; `canInc`/`canDec` drive the +/- buttons'
+ * enabled state. Emits `valueChanged` with the resolved value.
+ */
+declare class StepperControl extends Control {
+    private readonly bus?;
+    readonly states: StateMap;
+    readonly index: Signal<number>;
+    /** Optional caption (e.g. "Bet"). */
+    readonly label?: string;
+    private levels;
+    constructor(opts: StepperOptions, bus?: EventBus<OpenUIEvents> | undefined);
+    private clampIndex;
+    get value(): number;
+    get canInc(): boolean;
+    get canDec(): boolean;
+    inc(): void;
+    dec(): void;
+    setIndex(i: number): void;
+    /** Replace the level list (e.g. when the currency/limits change). */
+    setLevels(levels: number[], index?: number): void;
+}
+
+/**
+ * How tapping autoplay behaves:
+ * - `'options'` — tap opens a picker (a bottom drawer) to choose a spin count, then Start.
+ * - `'infinite'` — tap starts infinite autoplay immediately; tap again stops. No picker.
+ */
+type AutoplayMode = 'options' | 'infinite';
+/** Responsible-gambling stop limits for an autoplay session (multiples of bet). */
+interface AutoplayLimits {
+    /** Stop when cumulative net loss reaches `lossLimit × bet`. Infinity = no limit. */
+    lossLimit?: number;
+    /** Stop on a single win ≥ `singleWinLimit × bet`. Infinity = no limit. */
+    singleWinLimit?: number;
+}
+interface AutoplayOptions {
+    id: string;
+    layout: LayoutSpec;
+    /** Count choices shown in the picker. Use Infinity for "∞". */
+    options?: number[];
+    /** Tap behavior. Default `'options'`. */
+    mode?: AutoplayMode;
+    /**
+     * Optional responsible-gambling limit choices offered in the picker (multiples
+     * of the bet; Infinity = "no limit"). When present, the picker shows a
+     * "stop if total loss reaches N×" / "stop on a single win ≥ N×" row, and the
+     * host must feed each round's outcome via {@link AutoplayControl.reportResult}.
+     */
+    lossLimitOptions?: number[];
+    winLimitOptions?: number[];
+}
+/**
+ * Autoplay button. In `'options'` mode, tapping (idle) opens a count picker;
+ * choosing a count starts autoplay. In `'infinite'` mode, tapping starts infinite
+ * autoplay straight away. While active it shows the live remaining count (fed by
+ * the host via `setCount`); tapping stops. open-ui owns the picker UI + the
+ * displayed count; the host runs the actual spin loop.
+ */
+declare class AutoplayControl extends Control {
+    private readonly bus?;
+    readonly states: StateMap;
+    /** Remaining spins while active (Infinity = ∞). 0 when not active. */
+    readonly count: Signal<number>;
+    private _options;
+    private _lossLimitOptions;
+    private _winLimitOptions;
+    /** Active stop-on-total-loss (multiples of bet; Infinity = no limit). */
+    lossLimit: number;
+    /** Active stop-on-single-win (multiples of bet; Infinity = no limit). */
+    singleWinLimit: number;
+    /** Running net loss this autoplay session (bet − win, summed). */
+    private netLoss;
+    /** Tap behavior (`'options'` opens the picker, `'infinite'` starts immediately). */
+    mode: AutoplayMode;
+    constructor(opts: AutoplayOptions, bus?: EventBus<OpenUIEvents> | undefined);
+    /** Count choices shown in the picker (Infinity allowed = ∞). */
+    get options(): number[];
+    /** Loss-limit choices for the picker (multiples of bet; Infinity = no limit). */
+    get lossLimitOptions(): number[];
+    /** Single-win-stop choices for the picker (multiples of bet; Infinity = no limit). */
+    get winLimitOptions(): number[];
+    /** Replace the picker's count choices (e.g. when limits change). */
+    setOptions(options: number[]): void;
+    /** Replace the picker's loss-limit / single-win-stop choices. */
+    setLossLimitOptions(options: number[]): void;
+    setWinLimitOptions(options: number[]): void;
+    get isActive(): boolean;
+    openPicker(): void;
+    cancelPicker(): void;
+    /** Choose a count (+ optional RG limits) from the picker → start autoplay. */
+    pick(count: number, limits?: AutoplayLimits): void;
+    /** Start autoplay with a count (Infinity = ∞) + optional RG limits, from idle or
+     *  the picker. The limits are enforced as the host reports each round's outcome
+     *  via {@link reportResult}. */
+    begin(count: number, limits?: AutoplayLimits): void;
+    /**
+     * The host reports one completed autoplay round's outcome (major units) — this is
+     * the responsible-gambling guardrail. It advances the remaining count and stops
+     * autoplay if: the count is exhausted, the cumulative net loss reaches the
+     * loss-limit, or this single win reaches the single-win-stop. No-op when autoplay
+     * isn't active or the inputs are malformed (Charter P11).
+     */
+    reportResult(win: number, bet: number): void;
+    stop(): void;
+    /** Host updates the remaining count during play. Infinity is valid (∞); only
+     *  NaN/non-number is rejected, so bad host data never corrupts the badge (P11). */
+    setCount(n: number): void;
+    /** The view's tap handler. In `'infinite'` mode, idle starts straight away;
+     *  in `'options'` mode, idle opens the picker. Active always stops. */
+    press(): void;
+    disable(): void;
+    enable(): void;
+}
+
+/**
+ * What a readout shows:
+ * - `'percent'`  → a number + "%"            (RTP disclosure — `displayRTP`)
+ * - `'currency'` → a signed currency amount  (net position — `displayNetPosition`)
+ * - `'duration'` → an elapsed clock the view ticks (session timer — `displaySessionTimer`)
+ * - `'plain'`    → the grouped number
+ */
+type ReadoutKind = 'percent' | 'currency' | 'duration' | 'plain';
+interface ReadoutOptions {
+    id: string;
+    layout: LayoutSpec;
+    kind?: ReadoutKind;
+    label?: string;
+    /** Initial value (percent: 96, currency: major units, duration: seconds). */
+    value?: number;
+    /** Decimals for `percent`/`plain`. Default 1 for percent, 0 otherwise. */
+    decimals?: number;
+    /** Currency descriptor for the `currency` kind. */
+    currency?: CurrencySpec;
+    /** Whether a `currency` readout shows an explicit +/- sign. Default true. */
+    signed?: boolean;
+}
+/**
+ * A small, non-interactive text readout for the compliance display elements Stake
+ * Engine's jurisdiction config can mandate: RTP (`displayRTP`), net position
+ * (`displayNetPosition`), and the session timer (`displaySessionTimer`). It is the
+ * single source of truth for the value; the renderer formats it (and, for
+ * `'duration'`, ticks it). Hidden by default — `applyJurisdiction` reveals the ones
+ * a jurisdiction requires. Never-reject inbound boundary (Charter P11).
+ */
+declare class ReadoutControl extends Control {
+    readonly states: StateMap;
+    readonly value: Signal<number>;
+    /** Whether a `'duration'` readout is currently advancing. */
+    readonly running: Signal<boolean>;
+    readonly kind: ReadoutKind;
+    readonly label?: string;
+    readonly decimals: number;
+    readonly signed: boolean;
+    /** Present for the `'currency'` kind so the view can format + react to changes. */
+    readonly currency?: Signal<CurrencySpec>;
+    constructor(opts: ReadoutOptions);
+    /** Never-reject: malformed input keeps the last good value (P11). */
+    set(v: number): void;
+    get(): number;
+    setCurrency(spec: CurrencySpec): void;
+    /** Advance an elapsed-time readout by `deltaSec` (the renderer calls this each frame). */
+    tick(deltaSec: number): void;
+    start(): void;
+    stop(): void;
+    reset(): void;
+}
+
+interface CardOptions {
+    id: string;
+    layout: LayoutSpec;
+    /** Card title (e.g. the feature name). */
+    title?: string;
+    /** Price / cost shown on the card (formatted string or number). */
+    price?: string;
+    /** Asset id/key for the card image (resolved by the view/host). */
+    image?: string;
+}
+/**
+ * A selectable buy-feature card: image + title + price + a buy action.
+ * Emits `cardActivated` on a valid press-release. Lives inside a buy-feature panel.
+ */
+declare class CardControl extends Control {
+    private readonly bus?;
+    readonly states: StateMap;
+    title?: string;
+    price?: string;
+    image?: string;
+    constructor(opts: CardOptions, bus?: EventBus<OpenUIEvents> | undefined);
+    enable(): void;
+    disable(): void;
+    /** The view calls this on a valid press-release. */
+    activate(): void;
+}
+
+interface SelectOption {
+    value: string;
+    label: string;
+}
+interface SelectControlOptions {
+    id: string;
+    layout: LayoutSpec;
+    options: SelectOption[];
+    index?: number;
+    /** Caption shown beside the control (e.g. "Language"). */
+    label?: string;
+    role?: string;
+}
+/**
+ * A single-choice select (language, quality, …). FSM peer of StepperControl:
+ * `closed | open | disabled`. Tapping cycles or opens a list; all logic is
+ * headless and the renderer just draws it. Emits its OWN typed `optionSelected`
+ * event rather than overloading the numeric `valueChanged` (Charter B1, P5).
+ */
+declare class SelectControl extends Control {
+    private readonly bus?;
+    readonly states: StateMap;
+    readonly index: Signal<number>;
+    /** Caption (e.g. "Language") — distinct from the selected option's label. */
+    readonly caption?: string;
+    private _options;
+    constructor(opts: SelectControlOptions, bus?: EventBus<OpenUIEvents> | undefined);
+    private clamp;
+    get options(): ReadonlyArray<SelectOption>;
+    get value(): string;
+    get optionLabel(): string;
+    get isOpen(): boolean;
+    openList(): void;
+    closeList(): void;
+    /** Choose by value (the view's list-item handler). Closes the list. */
+    choose(value: string): void;
+    /** Jump to an index (clamped). Emits only if it changed. */
+    setIndex(i: number): void;
+    /** Advance to the next option, wrapping (the view's cycle-on-tap handler). */
+    cycle(): void;
+    /** Replace the option list (e.g. when limits or locale change). */
+    setOptions(options: SelectOption[], index?: number): void;
+    enable(): void;
+    disable(): void;
+}
+
+/** Built-in presets. open-ui ships a SINGLE canonical look — black & white with a
+ *  yellow accent (the `default` token theme). Hosts restyle via `ThemeOverrides`
+ *  (sanitized colours/radius/font), so the library stays themeable without shipping
+ *  a palette zoo. Unknown preset names resolve to `default`. */
+type ThemePreset = 'default';
+/**
+ * The SAFE, curated surface a host may override (Charter P8 + "configure, don't
+ * break"). Deliberately a subset of the full `Theme`: colours, corner radii, and
+ * the font family — the look knobs. Structural tokens (spacing, motion timing,
+ * font sizes) are NOT exposed, so a theme can restyle the HUD but cannot break its
+ * layout or timing. Every value is validated/clamped at runtime too (see below).
+ */
+interface ThemeOverrides {
+    color?: Partial<Theme['color']>;
+    radius?: Partial<Theme['radius']>;
+    type?: {
+        family?: string;
+    };
+}
+/** A reportable theme problem (structurally a `SpecIssue`, kept dependency-free). */
+interface ThemeIssue {
+    level: 'warn' | 'error';
+    path: string;
+    code: string;
+    message: string;
+}
+/**
+ * What a host can pass for `theme`: a preset name, a safe override (layered on the
+ * default), or `{ preset, overrides }` to layer a safe override on a chosen preset.
+ */
+type ThemeChoice = ThemePreset | ThemeOverrides | {
+    preset?: ThemePreset;
+    overrides?: ThemeOverrides;
+};
+/** The one ready-to-use theme: black & white with a yellow accent (`defaultTheme`). */
+declare const themePresets: Readonly<Record<ThemePreset, Theme>>;
+/** True for a colour string the renderer can safely use. */
+declare function isSafeColor(v: unknown): v is string;
+/**
+ * Turn host overrides into a guaranteed-safe `DeepPartial<Theme>`: invalid colours
+ * are dropped (the base token shows through), radii are clamped to a sane range,
+ * and a non-string font family is ignored. Each rejection is reported, never fatal.
+ */
+declare function sanitizeThemeOverrides(ov: ThemeOverrides, onIssue?: (i: ThemeIssue) => void): DeepPartial<Theme>;
+/**
+ * Resolve any `ThemeChoice` into a concrete, frozen Theme. Overrides are
+ * sanitized first, so a host can restyle the HUD but never break it: bad values
+ * fall back to the safe token (Charter P8/G5/P11). Pass `onIssue` to surface
+ * rejections (createUI forwards these to `HostHooks.onDataIssue`).
+ */
+declare function resolveTheme(choice?: ThemeChoice, onIssue?: (i: ThemeIssue) => void): Theme;
+
+/**
+ * Never-reject inbound boundary helpers (Charter P11). The UI *displays* values
+ * the host sets and computes no money — so malformed host data must degrade to a
+ * no-op, never throw into the render loop.
+ */
+/** Return `n` if it is a finite number, else fall back to the last good value. */
+declare function safeAmount(n: number, lastGood: number): number;
+/** Clamp a currency's fractional digits to a sane 0..8 integer (default 2). */
+declare function clampDecimals(d: number): number;
+/** Clamp the value counter's fit WIDTH budget to a sane 1..18 column count (default 9). */
+declare function clampDigits(n: number): number;
+/** Clamp a value-display's MINIMUM column width: 0..18, where 0 means "auto" — size
+ *  the odometer tightly to the value. Garbage → 0 (auto). */
+declare function clampMinDigits(n: number): number;
+/** How many integer (whole-part) digits a value needs, minimum 1 (so `0.x` shows a
+ *  leading `0`). Uses string length, not log10, to dodge the `log10(1000)=2.999…` trap. */
+declare function integerDigits(value: number): number;
+/**
+ * Total odometer columns to show `value` at `decimals` precision TIGHTLY — exactly
+ * the integer digits the value needs plus the fraction columns, so there are no
+ * hidden leading-zero columns padding the number (a fixed reserve would either gap
+ * small values like `$1.00` or clamp large ones like `12.34 BTC` on a 9-col budget).
+ * Never below `minTotal` (a host-set stable width) nor `decimals + 1` (the counter
+ * needs `decimals < digits`); capped at 18. The renderer grows the counter as the
+ * value grows, so the magnitude is never clamped.
+ */
+declare function displayDigits(value: number, minTotal: number, decimals: number): number;
+/**
+ * On-screen width budget (px) the value counter is allowed before `fit` scales it
+ * down. Keyed to a fixed display budget (≥ 9 columns, or the host's wider `digits`)
+ * so a normal-magnitude readout renders full-size while a very large value scales to
+ * fit ("won't go too far"). `+64` leaves room for the currency affix.
+ */
+declare function valueFitMaxWidth(digits: number, columnWidth: number): number;
+
+/**
+ * The unified MENU: one scrollable surface opened by the ☰ button, composed of
+ * three ordered sections — Settings (Music/Sound + a Language switch + your
+ * extras), Paytable, then Rules. `composeMenu` is pure: it flattens a `MenuSpec`
+ * into the ordered `BlockSpec[]` the renderer draws, injecting section headings.
+ * Section text is localizable (it flows through `ui.t` in the view).
+ */
+
+interface MenuSpec {
+    /** A banner image shown at the very top of the menu (e.g. a themed title art). */
+    banner?: {
+        src: string;
+        width?: number;
+        height?: number;
+    };
+    /** Extra settings, appended after the built-in Music/Sound (+ Language). */
+    settings?: BlockSpec[];
+    /** Paytable section content (omit → no Paytable section). */
+    paytable?: BlockSpec[];
+    /** Rules section content (omit → no Rules section). */
+    rules?: BlockSpec[];
+    /** Override the section heading text (each is run through `ui.t`). */
+    titles?: {
+        settings?: string;
+        paytable?: string;
+        rules?: string;
+    };
+}
+declare const DEFAULT_MENU_TITLES: {
+    readonly settings: "Settings";
+    readonly paytable: "Paytable";
+    readonly rules: "Rules";
+};
+/** Native names for the language switch; falls back to the upper-cased code.
+ *  Covers Stake Engine's locale set (ar de en es fr id ja ko pl pt ru tr vi zh fi hi). */
+declare const LOCALE_LABELS: Record<string, string>;
+interface ComposeMenuOptions {
+    /** Locale codes available — when 2+, a Language select is added to Settings. */
+    locales?: string[];
+    /** The select id that switches locale (must match createUI's localeSelectId). */
+    localeSelectId?: string;
+    /** Back-compat: a top-level `rules` array used when `menu.rules` is absent. */
+    rulesFallback?: BlockSpec[];
+}
+/**
+ * Compose the ordered menu blocks. The built-in Music/Sound sliders reuse the
+ * real `music`/`sfx` controls (the view's reuse resolver wires them), so the menu
+ * drives the actual volume — it doesn't shadow it.
+ */
+declare function composeMenu(menu: MenuSpec | undefined, opts?: ComposeMenuOptions): BlockSpec[];
+
+/**
+ * The notice / error modal model.
+ *
+ * The HUD shows a menu-style modal built from declarative {@link BlockSpec} content
+ * plus a row of action buttons. EVERY string — title, message, and each button
+ * label — is passed through the translator (`ui.t`), so the host can either pass the
+ * EXACT literal text they want, or a translation key they localize themselves (their
+ * `locale.messages` dict overrides the built-in English defaults). Nothing is
+ * hard-coded in the renderer, and every default is overridable per call.
+ */
+
+interface NoticeAction {
+    /** Button label — a literal string OR an i18n key (resolved via the translator). */
+    label: string;
+    /** Called when the button is pressed. */
+    onSelect?: () => void;
+    /** Also emit a `buttonActivated` event with this id (for analytics / host wiring). */
+    emit?: string;
+    /** Visual weight (default: first action `primary`, the rest `secondary`). */
+    variant?: 'primary' | 'secondary';
+    /** Keep the modal open after pressing (default: dismiss it). */
+    keepOpen?: boolean;
+}
+interface NoticeOptions {
+    /** Title — literal or i18n key. Default `'openui.error'` for errors. */
+    title?: string;
+    /** Callout tone. Default `'warning'` for errors. */
+    tone?: 'info' | 'warning' | 'bonus';
+    /** Action buttons. Omitted → a single dismiss button (`openui.ok`), or NONE when
+     *  `blocking` (so a fatal modal is dismissable only in code). */
+    actions?: NoticeAction[];
+    /** FATAL/blocking modal: locks the HUD, no backdrop/✕ dismiss; remove via `hideNotice`. */
+    blocking?: boolean;
+}
+/** Reality-check reminder config (RTS 13). You supply the cadence + text; open-ui
+ *  owns the (wall-clock) timer, the event, and the modal. */
+interface RealityCheckOptions {
+    /** Reminder interval in minutes (wall-clock). */
+    everyMinutes: number;
+    /** Modal title — literal or i18n key. `{{minutes}}`/`{{spent}}`/`{{won}}` interpolate. */
+    title?: string;
+    /** Modal message — literal or i18n key. Same interpolation tokens. */
+    message?: string;
+    /** Show the built-in acknowledge modal (default true). `false` → only the event fires. */
+    showModal?: boolean;
+    /** Custom action buttons (default a single "Continue"). */
+    actions?: NoticeAction[];
+}
+/** What `showRgsError` accepts: notice options plus an exact message override. */
+interface RgsErrorOptions extends NoticeOptions {
+    /** Override the default message for this code with exact text (or your own key). */
+    message?: string;
+    /** Stop an in-progress autoplay session (default true — most RGS errors should). */
+    stopAutoplay?: boolean;
+}
+/** RGS status codes open-ui ships a default message for (the TS enum + the HTTP groups). */
+type RgsErrorCode = 'ERR_IPB' | 'ERR_IS' | 'ERR_ATE' | 'ERR_GLE' | 'ERR_BE' | 'ERR_BNF' | 'ERR_LOC' | 'ERR_MAINTENANCE' | 'ERR_VAL' | 'ERR_GEN' | 'ERR_UE' | 'ERR_TIMEOUT';
+/**
+ * Code → default title/message i18n KEYS. The English text for these keys lives in
+ * the translator defaults (`openuiDefaults`), so a host localizes errors by adding
+ * those keys to their `messages` dict — or overrides any single one per call via
+ * `showRgsError(code, { title, message })`. Unknown codes fall back to generic.
+ */
+declare const RGS_ERROR_KEYS: Readonly<Record<string, {
+    title: string;
+    message: string;
+}>>;
+/** The default dismiss action used when a notice supplies none. */
+declare const DEFAULT_NOTICE_ACTION: NoticeAction;
+/** Build the title + message blocks for an error/notice (used by `showError`). */
+declare function errorBlocks(message: string, title: string, tone: NonNullable<NoticeOptions['tone']>): BlockSpec[];
+
+/**
+ * i18n port (Charter B5/B8): the core depends on this tiny interface, NOT on i18next.
+ * Ship adapters (`@open-slot-ui/i18n-i18next`, the built-in `dictionary()`), never a hard dep.
+ */
+interface Translator {
+    t(key: string, vars?: Record<string, string | number>): string;
+    readonly locale: string;
+    /** Switch the active locale (a no-op for the same locale); fires onChange. */
+    setLocale(next: string): void;
+    onChange(cb: (locale: string) => void): Dispose;
+}
+/** open-ui owns this namespace; the host's translator may override any key. */
+declare const openuiDefaults: Record<string, string>;
+/**
+ * Zero-dep dictionary translator. Falls back to open-ui defaults, then to the
+ * key itself only if nothing is found — but built-in keys always resolve, so the
+ * library never renders a raw key (the text analog of "never break un-themed").
+ */
+declare class DictionaryTranslator implements Translator {
+    private readonly messages;
+    private _locale;
+    private readonly subs;
+    constructor(messages: Record<string, Record<string, string>>, locale: string);
+    get locale(): string;
+    setLocale(next: string): void;
+    t(key: string, vars?: Record<string, string | number>): string;
+    onChange(cb: (locale: string) => void): Dispose;
+}
+/** Convenience factory for a zero-dep dictionary translator. */
+declare function dictionary(messages: Record<string, Record<string, string>>, locale: string): DictionaryTranslator;
+
+interface OpenUIOptions {
+    theme?: Theme;
+    layout?: LayoutConfig;
+    /** i18n port. Default: an empty dictionary on locale 'en' (keys fall through). */
+    translator?: Translator;
+    /** Start with audio muted (the icon reflects it). Unmute restores the volumes. */
+    startMuted?: boolean;
+}
+/**
+ * The headless root: owns the control tree, the active theme, the responsive
+ * screen state, and the typed event bus. This is the object the game holds and
+ * "talks to" (Charter P1/P4). Renderer-agnostic — a renderer binds to it.
+ */
+declare class OpenUI {
+    readonly theme: Theme;
+    readonly layoutConfig: LayoutConfig;
+    readonly bus: EventBus<OpenUIEvents>;
+    readonly screen: Signal<ScreenState>;
+    /** i18n translator (the port — no hard i18next dep, Charter B5/B8). */
+    readonly translator: Translator;
+    /** Current locale, observable — views re-render their text when it changes. */
+    readonly locale: Signal<string>;
+    /**
+     * Ref-counted input lock. While the count is above zero, `locked` is true and
+     * EVERY registered control reports not-interactable through its derived getter
+     * (Charter P6/G7) — no per-button bookkeeping, no desync. Instance-scoped: the
+     * gate each control receives in `register` reads THIS ui's `locked`.
+     */
+    readonly locked: Signal<boolean>;
+    private lockCount;
+    /** Every subscription this ui owns, torn down by `dispose()` (Charter P12). */
+    private readonly disposers;
+    /** Control ids the spec marked hidden — still registered (so they stay
+     *  introspectable in `snapshot()`) but skipped by the renderer (Charter P10). */
+    readonly hidden: Set<string>;
+    /** Ids hidden UNCONDITIONALLY (e.g. a jurisdiction `disabled*` flag): `setHidden`
+     *  refuses to re-show these, so a responsive resize can't undo a compliance hide. */
+    readonly forceHidden: Set<string>;
+    /** Master mute (music+sfx), observable so an icon can reflect it. */
+    readonly muted: Signal<boolean>;
+    /** Social / sweepstakes mode: swaps gambling wording (Bet/Buy → social terms) and,
+     *  paired with a social coin, shows GC/SC. Toggle with {@link setSocial}. */
+    readonly social: Signal<boolean>;
+    /** Declarative blocks backing the menu-style notice/error modal. */
+    readonly noticeBlocks: Signal<BlockSpec[]>;
+    /** Action buttons for the notice/error modal (a single dismiss when empty). */
+    readonly noticeActions: Signal<NoticeAction[]>;
+    /** Whether the open notice is a BLOCKING/fatal modal — no backdrop/✕ dismiss and
+     *  the HUD is locked; it can be removed only in code (`hideNotice`). */
+    readonly noticeBlocking: Signal<boolean>;
+    private noticeLockHeld;
+    /** Cumulative amount staked this session (major units) — RTS 12 "money spent". */
+    readonly totalStaked: Signal<number>;
+    /** Cumulative amount won this session (major units). */
+    readonly totalWon: Signal<number>;
+    /** The Stake jurisdiction config currently applied (read-back for guards/queries). */
+    jurisdiction: Readonly<JurisdictionConfig>;
+    /** Replay mode (Stake `replay=true`): the HUD locks + a REPLAY badge shows. */
+    readonly replay: Signal<boolean>;
+    /** Game name + version (shown in the menu footer; for support / certification). */
+    gameInfo: {
+        name?: string;
+        version?: string;
+    };
+    /** Minimum round duration (ms) from jurisdiction — stored for the GAME to enforce. */
+    minimumRoundDuration: number;
+    private sessionNet;
+    private prevVolumes;
+    /** The frozen UISpec `createUI` built this from, if any — authored = run = tested. */
+    spec?: Readonly<UISpec>;
+    /** Typed convenience handles for the controls. */
+    readonly spin: SpinControl;
+    readonly balance: ValueDisplay;
+    readonly bet: ValueDisplay;
+    readonly settingsButton: ButtonControl;
+    readonly settingsPanel: PanelControl;
+    readonly musicSlider: SliderControl;
+    readonly sfxSlider: SliderControl;
+    readonly rulesButton: ButtonControl;
+    readonly infoPanel: PanelControl;
+    readonly infoClose: ButtonControl;
+    readonly turbo: TurboControl;
+    readonly autoplay: AutoplayControl;
+    readonly bonusButton: ButtonControl;
+    readonly betStepper: StepperControl;
+    readonly betPlus: ButtonControl;
+    readonly betMinus: ButtonControl;
+    readonly fullscreenButton: ButtonControl;
+    readonly muteButton: ButtonControl;
+    /** Compliance display readouts — hidden until a jurisdiction reveals them. */
+    readonly rtp: ReadoutControl;
+    readonly netPosition: ReadoutControl;
+    readonly sessionTimer: ReadoutControl;
+    /** Menu-style notice/error modal (content set via `showNotice`). */
+    readonly noticePanel: PanelControl;
+    private readonly controls;
+    constructor(opts?: OpenUIOptions);
+    register(control: Control): void;
+    control(id: string): Control | undefined;
+    all(): Control[];
+    /** Renderer calls this on resize; recomputes breakpoint + fit scale. */
+    setScreen(width: number, height: number): void;
+    /**
+     * Hide or show a control at runtime and tell the renderer (Charter P10). The
+     * control stays registered — still in `snapshot()` — but the view is not drawn.
+     * Used by the responsive layer to drop controls on small screens.
+     */
+    setHidden(id: string, hidden: boolean): void;
+    /** Push the ref-counted input lock (e.g. for the duration of a spin round). */
+    lock(): void;
+    /** Pop the lock; the HUD becomes interactable again only at zero. */
+    unlock(): void;
+    /** Toggle master mute (music + sfx). */
+    toggleMute(): void;
+    /** Mute/unmute music+sfx, remembering the levels to restore on unmute. */
+    setMuted(m: boolean): void;
+    /**
+     * Report one completed round (major units): updates the net-position readout and,
+     * while autoplay is running, advances its count + enforces its RG loss/single-win
+     * limits. One feed point powers both `displayNetPosition` and the autoplay stops.
+     */
+    reportRound(win: number, bet: number): void;
+    /** Reset the running session net + aggregates + timer (e.g. on a fresh session). */
+    resetSession(): void;
+    /** Show the menu-style notice modal: declarative blocks + optional action buttons.
+     *  Every string (block text + button labels) runs through `ui.t`, so pass exact
+     *  literals OR your own i18n keys. Omit `actions` → a single dismiss button. */
+    showNotice(blocks: BlockSpec[], actions?: NoticeAction[], opts?: {
+        blocking?: boolean;
+    }): void;
+    /** Show a simple error/notice: a title + a tone-coloured message. `message` and
+     *  `opts.title` are literal-or-key (localized via `ui.t`); `opts.actions` adds
+     *  custom buttons (e.g. a "Reload"). `opts.blocking` → a fatal modal (locks the
+     *  HUD, no backdrop/✕ dismiss; removable only via `hideNotice`). */
+    showError(message: string, opts?: NoticeOptions): void;
+    /** Show a FATAL error: a blocking modal that locks the HUD and can be removed only
+     *  in code (`hideNotice`) — for unrecoverable RGS states. Pass `actions` (e.g. a
+     *  "Reload" that reloads the page) for the only way out. */
+    showFatal(message: string, opts?: NoticeOptions): void;
+    /** Show the default (localizable, overridable) message for an RGS status code.
+     *  Override the exact text per call via `opts.title` / `opts.message`. Stops an
+     *  active autoplay by default (`opts.stopAutoplay = false` to keep it). Pass
+     *  `opts.blocking` for unrecoverable codes (session expiry, maintenance). */
+    showRgsError(code: string, opts?: RgsErrorOptions): void;
+    /** Close the notice / error modal. */
+    hideNotice(): void;
+    /** Enter/leave replay mode (Stake `replay=true`) — locks the HUD so no real bet is
+     *  placed; the renderer shows a REPLAY badge while it's on. */
+    setReplay(on: boolean): void;
+    /** Apply a Stake Engine `jurisdiction` config to the live HUD (whole switchboard).
+     *  The merged config is stored for `isDisabled()` read-back. */
+    applyJurisdiction(jur: JurisdictionConfig): void;
+    /** Tear down every subscription and control this ui created (Charter P12). */
+    dispose(): void;
+    /**
+     * Switch language. Drives the translator (if it can self-switch) and emits
+     * `localeChanged`; controls' views, subscribed to `locale`, re-render their text.
+     */
+    setLocale(next: string): void;
+    /** Translate a key (or pass plain text through) via the active translator. In
+     *  social mode, a `<key>.social` variant wins when one resolves — so gambling
+     *  wording (Bet/Buy feature) swaps to sweepstakes terms automatically. */
+    t(key: string, vars?: Record<string, string | number>): string;
+    /**
+     * Turn social / sweepstakes mode on or off (one switch). Swaps gambling wording
+     * (Bet/Buy feature → social terms via `<key>.social` i18n) AND, when a `coin` is
+     * given (e.g. `'GC'`/`'SC'`/`'XGC'`), shows balance/bet/net in that coin. Wording
+     * re-renders live; the host can still override any `.social` key.
+     */
+    setSocial(on: boolean, coin?: string): void;
+    /** Read-back: did the applied jurisdiction disable this feature? (real guard, not
+     *  just a hide — `confirmBuy`/autoplay entry points consult this). */
+    isDisabled(feature: 'autoplay' | 'buyFeature' | 'turbo' | 'superTurbo' | 'fullscreen' | 'slamstop' | 'spacebar'): boolean;
+    /**
+     * Start a reality-check reminder (RTS 13). Every `everyMinutes` (WALL-CLOCK, so a
+     * backgrounded tab can't cheat it) it emits a `realityCheck` event, stops autoplay,
+     * and — unless `showModal: false` — shows an acknowledge modal. You provide only
+     * the interval + (optional) title/message text; `{{minutes}}`/`{{spent}}`/`{{won}}`
+     * are interpolated. Returns a disposer (also torn down by `dispose()`).
+     */
+    startRealityCheck(opts: RealityCheckOptions): Dispose;
+    /** Fire one reality check now: emit the event (+ session totals), stop autoplay,
+     *  and show the modal unless `showModal:false`. Exposed for manual triggers / tests. */
+    fireRealityCheck(opts: RealityCheckOptions, elapsedMs?: number): void;
+    on<K extends keyof OpenUIEvents>(type: K, fn: (payload: OpenUIEvents[K]) => void): Dispose;
+    /** Serializable snapshot for the introspection / e2e API (Charter P10). */
+    snapshot(): ControlSnapshot[];
+}
+
+/**
+ * Stake Engine's per-player jurisdiction config — the object the RGS returns at
+ * `/wallet/authenticate` as `config.jurisdiction`. It is the platform's regulatory
+ * switchboard: each `disabled*` flag must HIDE/limit a feature, each `display*`
+ * flag must SHOW a readout, and `minimumRoundDuration` is a hint the GAME enforces
+ * (open-ui never throttles the round). Every field is optional — an omitted flag
+ * leaves the HUD's configured default untouched.
+ *
+ * @see https://github.com/StakeEngine/web-sdk — packages/rgs-fetcher/src/schema.ts
+ */
+interface JurisdictionConfig {
+    /** Social / sweepstakes mode (coins shown as GC/SC). */
+    socialCasino?: boolean;
+    disabledFullscreen?: boolean;
+    disabledTurbo?: boolean;
+    disabledSuperTurbo?: boolean;
+    disabledAutoplay?: boolean;
+    disabledSlamstop?: boolean;
+    disabledSpacebar?: boolean;
+    disabledBuyFeature?: boolean;
+    displayNetPosition?: boolean;
+    displayRTP?: boolean;
+    displaySessionTimer?: boolean;
+    /** Minimum ms a round must take — stored on the HUD for the GAME to enforce. */
+    minimumRoundDuration?: number;
+}
+/**
+ * Apply a Stake Engine `jurisdiction` config to a live HUD — the whole switchboard
+ * in one call. Safe to run at any time (typically right after the game
+ * authenticates and learns the player's jurisdiction): it only acts on the flags
+ * that are set, so it composes with the game's own `controls`/`responsive` config
+ * and is idempotent. `disabled*` hides are made permanent (resize-proof) via
+ * `ui.forceHidden`; `display*` flags reveal/hide the mandated readouts. It reuses
+ * the primitives open-ui already has, so honoring the platform is one line.
+ */
+declare function applyJurisdiction(ui: OpenUI, jur: JurisdictionConfig | undefined): void;
+
+/**
+ * The JSON-serializable UISpec — the single source of truth that builds the
+ * control tree, drives e2e, and powers the docs panel editor (the "SpecKit"
+ * design). Authoring it is type-checked; `validateSpec` guards it at runtime;
+ * `createUI` assembles it over the existing OpenUI machinery.
+ */
+
+/** The reference-HUD control ids — typed so a typo is a compile error. */
+type KnownControlId = 'spin' | 'balance' | 'bet' | 'settings' | 'settings-panel' | 'music' | 'sfx' | 'rules' | 'info-panel' | 'info-close' | 'turbo' | 'autoplay' | 'bonus' | 'bet-stepper' | 'bet-plus' | 'bet-minus' | 'fullscreen' | 'mute' | 'rtp' | 'net-position' | 'session-timer' | 'notice-panel';
+/** One issue from the never-throw validator. */
+interface SpecIssue {
+    level: 'error' | 'warn';
+    path: string;
+    code: string;
+    message: string;
+}
+/** Host-owned side effects, injected (the lib performs none itself — Charter B8). */
+interface HostHooks {
+    onDataIssue?(issue: SpecIssue): void;
+    onAnalyticsEvent?: <K extends keyof OpenUIEvents>(type: K, payload: OpenUIEvents[K]) => void;
+}
+/** A targeted override for one shipped control. Anything omitted keeps the default. */
+interface ControlOverride {
+    layout?: LayoutSpec;
+    label?: string;
+    hidden?: boolean;
+    disabled?: boolean;
+    currency?: CurrencySpec;
+    initial?: number;
+    /** Value-display only: MINIMUM odometer column width. `0`/unset = auto — the counter
+     *  is sized tightly to the value (symbol hugs the number) and grows as it does, so
+     *  balances never clamp. Set it only to reserve a stable, wider readout. Clamped
+     *  0..18; ignored by non-value controls. Default 0 (auto). */
+    digits?: number;
+}
+/**
+ * Turbo switcher config. Choose how many modes the one Turbo control cycles
+ * through — `2` (off/on) or `3` (off/turbo/super) — or pass explicit mode names.
+ */
+interface TurboSpec {
+    /** `2` → off/on · `3` → off/turbo/super · or a custom ordered ladder (first = off). */
+    modes?: 2 | 3 | string[];
+    /** Initial mode index (0 = off). */
+    index?: number;
+}
+/** How pressing the spin button behaves. */
+type SpinPress = 'tap' | 'hold-to-spin';
+interface SpinSpec {
+    /** `'tap'` = one spin per tap · `'hold-to-spin'` = turbo-spin while held. Default `'tap'`. */
+    press?: SpinPress;
+}
+/** A responsive bucket the config can target: a device size OR an orientation. */
+type ResponsiveKey = Breakpoint | Orientation;
+/** What a responsive bucket may change. Layout + visibility, per control. */
+interface ResponsiveOverride {
+    controls?: Record<string, Pick<ControlOverride, 'layout' | 'hidden'>>;
+}
+/**
+ * A declarative menu/panel content block. Discriminated by `kind` so a "shown but
+ * no payload" bug is uncompilable (Charter B10): a `select` cannot omit options,
+ * a `slider` cannot carry them.
+ */
+type BlockSpec = {
+    kind: 'slider';
+    id: string;
+    label?: string;
+    initial?: number;
+} | {
+    kind: 'toggle';
+    id: string;
+    label?: string;
+    on?: boolean;
+} | {
+    kind: 'button';
+    id: string;
+    label: string;
+    action?: 'closePanel' | 'openPanel' | 'emit';
+    target?: string;
+    role?: string;
+} | {
+    kind: 'select';
+    id: string;
+    label?: string;
+    options: SelectOption[];
+    index?: number;
+} | {
+    kind: 'stepper';
+    id: string;
+    label?: string;
+    levels: number[];
+    index?: number;
+} | {
+    kind: 'value';
+    id: string;
+    label?: string;
+    currency?: CurrencySpec;
+    initial?: number;
+} | {
+    kind: 'text';
+    id: string;
+    text: string;
+} | {
+    kind: 'heading';
+    id: string;
+    text: string;
+} | {
+    kind: 'subheading';
+    id: string;
+    text: string;
+} | {
+    kind: 'callout';
+    id: string;
+    tone?: 'info' | 'bonus' | 'warning';
+    title?: string;
+    text: string;
+} | {
+    kind: 'stat-grid';
+    id: string;
+    items: Array<{
+        label: string;
+        value: string;
+    }>;
+} | {
+    kind: 'steps';
+    id: string;
+    ordered?: boolean;
+    items: string[];
+} | {
+    kind: 'table';
+    id: string;
+    columns?: string[];
+    rows: string[][];
+} | {
+    kind: 'paytable';
+    id: string;
+    columns?: number;
+    rows: Array<{
+        symbol?: string;
+        payouts: string;
+        icon?: string;
+    }>;
+} | {
+    kind: 'image';
+    id: string;
+    src: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+} | {
+    kind: 'media';
+    id: string;
+    src: string;
+    alt?: string;
+    side?: 'left' | 'right';
+    title?: string;
+    text: string;
+    width?: number;
+    height?: number;
+} | {
+    kind: 'cards';
+    id: string;
+    items: Array<{
+        icon?: string;
+        title: string;
+        text?: string;
+    }>;
+} | {
+    kind: 'legal';
+    id: string;
+    text: string;
+} | {
+    kind: 'divider';
+    id: string;
+} | {
+    kind: 'group';
+    id: string;
+    title?: string;
+    children: BlockSpec[];
+};
+/** All block kinds, for runtime validation of untyped host data. */
+declare const BLOCK_KINDS: readonly ["slider", "toggle", "button", "select", "stepper", "value", "text", "heading", "subheading", "callout", "stat-grid", "steps", "table", "paytable", "image", "media", "cards", "legal", "divider", "group"];
+interface PanelSpec {
+    id: string;
+    variant: PanelVariant;
+    title?: string;
+    layout?: LayoutSpec;
+    blocks: BlockSpec[];
+}
+/** The whole UI as one optional, JSON-serializable object. Omit any field → default. */
+interface UISpec {
+    meta?: {
+        id: string;
+        version: number;
+    };
+    theme?: ThemeChoice;
+    layout?: LayoutConfig;
+    /** Balance + bet currency: a full spec, or a code string (e.g. `'JPY'`, `'XGC'`)
+     *  auto-resolved (decimals, social coins) via the built-in currency table. */
+    currency?: CurrencySpec | string;
+    betLadder?: {
+        levels: number[];
+        index?: number;
+    };
+    /**
+     * Autoplay count choices + tap behavior (`'options'` drawer or `'infinite'`), plus
+     * optional responsible-gambling limit choices (multiples of bet; Infinity = none).
+     * When `lossLimits`/`winLimits` are set, the picker offers them and the host must
+     * feed each round to `hud.reportRound(win, bet)` so they're enforced.
+     */
+    autoplay?: {
+        options?: number[];
+        mode?: AutoplayMode;
+        lossLimits?: number[];
+        winLimits?: number[];
+    };
+    /** Turbo switcher: 2-mode (off/on) or 3-mode (off/turbo/super). */
+    turbo?: TurboSpec;
+    /** Spin button behavior: single `'tap'` or `'hold-to-spin'` turbo. */
+    spin?: SpinSpec;
+    /**
+     * Per-device / per-orientation overrides, layered on top of `controls`. Keys are
+     * `'mobile' | 'tablet' | 'desktop'` (device size) and `'portrait' | 'landscape'`
+     * (orientation); on each resize the matching buckets re-apply, so the HUD can
+     * reflow or drop controls per screen. Order: base → orientation → size.
+     */
+    responsive?: Partial<Record<ResponsiveKey, ResponsiveOverride>>;
+    controls?: Partial<Record<KnownControlId, ControlOverride>> & Record<string, ControlOverride>;
+    /** The unified scrollable MENU opened by ☰: Settings → Paytable → Rules. */
+    menu?: MenuSpec;
+    /** Back-compat: rules blocks, folded into the menu's Rules section if `menu.rules` is absent. */
+    rules?: BlockSpec[];
+    /** Additional declarative panels. */
+    panels?: PanelSpec[];
+    /** i18n dictionary + starting locale (built into a DictionaryTranslator). */
+    locale?: {
+        messages: Record<string, Record<string, string>>;
+        locale: string;
+    };
+    /** Block/control id whose `optionSelected` switches the locale. Default 'lang'. */
+    localeSelectId?: string;
+    /** Auto-lock the whole HUD while the spin control is spinning. Default true. */
+    lockDuringSpin?: boolean;
+    /**
+     * Stake Engine per-player jurisdiction config — the compliance switchboard. Usually
+     * known only after the game authenticates, so prefer the runtime
+     * `hud.applyJurisdiction(jur)`; set it here when known up front (createUI applies it
+     * before the responsive layer so `disabled*` hides survive resizes).
+     */
+    jurisdiction?: JurisdictionConfig;
+    /** Initial RTP percentage for the RTP readout (e.g. 96 → "96.0%"). */
+    rtp?: number;
+    /** Put the compliance readouts (net · RTP · session) in a thin status bar pinned
+     *  to the `'top'` or `'bottom'` edge instead of at screen corners. */
+    statusBar?: 'top' | 'bottom';
+    /** Game name + version — shown in the menu footer (support / certification). */
+    game?: {
+        name?: string;
+        version?: string;
+    };
+    /** Reality-check reminder (RTS 13): open-ui runs a wall-clock timer, emits a
+     *  `realityCheck` event, stops autoplay, and (unless `showModal:false`) shows an
+     *  acknowledge modal. You supply only the cadence + text. `title`/`message` are
+     *  literal-or-key with `{{minutes}}`/`{{spent}}`/`{{won}}` interpolation. */
+    realityCheck?: {
+        everyMinutes: number;
+        title?: string;
+        message?: string;
+        showModal?: boolean;
+    };
+    /** Social / sweepstakes mode: `true` swaps gambling wording (Bet/Buy → social
+     *  terms); `{ coin }` also shows balance/bet/net in that coin (e.g. `'GC'`/`'SC'`). */
+    social?: boolean | {
+        coin?: string;
+    };
+    /** Audio start state. `startMuted` boots muted (the mute icon reflects it; unmuting
+     *  restores the configured volumes). */
+    audio?: {
+        startMuted?: boolean;
+    };
+}
+/** The result of building a PanelSpec: the panel + every leaf control, in render order. */
+interface BuiltPanel {
+    panel: PanelControl;
+    controls: Control[];
+    blocks: BlockSpec[];
+}
+
+/**
+ * Resolves a declarative BlockSpec into a real Control. This is the swap-by-class
+ * seam (Charter P7): the defaults can be overridden per kind, so a game can drop
+ * in its own control class without forking. Keyed by block `kind`.
+ */
+
+type BlockFactory = (block: BlockSpec, bus: EventBus<OpenUIEvents>) => Control | null;
+declare class ControlRegistry {
+    private readonly factories;
+    register(kind: string, factory: BlockFactory): void;
+    has(kind: string): boolean;
+    /** Build the Control for a block, or null for non-control blocks / unknown kinds. */
+    resolve(block: BlockSpec, bus: EventBus<OpenUIEvents>): Control | null;
+    /** A registry with every built-in block kind wired to its reference control. */
+    static defaults(): ControlRegistry;
+}
+
+/**
+ * Never-throw spec validator (Charter P11/B9). Returns a report; callers
+ * (createUI) drop only the offending pieces and degrade — a malformed HUD still
+ * boots. Every guardrail check lives here; it is pure and unit-tested.
+ */
+
+declare function validateSpec(spec: UISpec): {
+    ok: boolean;
+    issues: SpecIssue[];
+};
+
+/** Resolve a block tree to its flat leaf controls, in render order. text/group carry none. */
+declare function buildBlocks(blocks: BlockSpec[], bus: EventBus<OpenUIEvents>, registry?: ControlRegistry, 
+/** If a block id already resolves to a control (e.g. a built-in like 'music'),
+ *  reuse it instead of building a shadow copy that would overwrite it. */
+reuse?: (id: string) => Control | undefined): Control[];
+declare function buildPanel(spec: PanelSpec, bus: EventBus<OpenUIEvents>, registry?: ControlRegistry): BuiltPanel;
+/** Flatten a block tree to its button blocks (used to wire panel actions). */
+declare function buttonBlocks(blocks: BlockSpec[]): Array<Extract<BlockSpec, {
+    kind: 'button';
+}>>;
+
+/**
+ * createUI(spec) — assemble a complete, configured OpenUI from one JSON UISpec,
+ * over the EXISTING reference HUD (Charter P1/P4/B9). Zero-arg `createUI()`
+ * reproduces today's 16-control HUD. Pure assembly: validate → apply overrides →
+ * wire the ref-counted spin lock → freeze the spec onto `ui.spec`.
+ */
+
+/** Resolve the turbo `modes` config (`2`/`3` presets or explicit names) to a ladder. */
+declare function resolveTurboModes(modes: TurboSpec['modes']): string[];
+/** Identity helper for typed authoring (IDE checks the shape); returns the spec. */
+declare function defineUI(spec: UISpec): UISpec;
+declare function createUI(spec?: UISpec, hooks?: HostHooks): OpenUI;
+
+/**
+ * The responsive layer: re-apply per-device / per-orientation control overrides
+ * every time the screen bucket changes. Pure assembly over the existing layout
+ * machinery — it only ever sets `control.layout` and toggles `ui.setHidden`, both
+ * of which the views already react to (Charter P6/P10). No new rendering concepts.
+ */
+
+type Responsive = Partial<Record<ResponsiveKey, ResponsiveOverride>>;
+/**
+ * Install responsive overrides. Snapshots each referenced control's CURRENT layout
+ * + hidden state as the "base" (so callers must apply static `controls` overrides
+ * first), then on every screen change re-derives base → orientation → size and
+ * applies it. Returns a disposer. Runs once immediately for the current screen.
+ */
+declare function installResponsive(ui: OpenUI, responsive: Responsive): Dispose;
+
+/**
+ * The reference HUD expressed as data — the knobs `new OpenUI()` ships with.
+ * `createUI(defaultHudSpec)` is byte-equivalent to zero-arg `createUI()` (a test
+ * guards this). It's the canonical starting point for the docs editor and for
+ * games that want to tweak from the default rather than start blank.
+ */
+declare const defaultHudSpec: Readonly<UISpec>;
+
+interface LoggedEvent {
+    t: number;
+    type: keyof OpenUIEvents;
+    payload: unknown;
+}
+interface EventLogOptions {
+    /** Max entries kept (ring buffer). Default 200. */
+    capacity?: number;
+    /** Monotonic clock; defaults to performance.now/Date.now. Injectable for tests. */
+    now?: () => number;
+}
+/**
+ * An opt-in ring buffer over the one typed event bus — backs `BootedHud.events`
+ * and the dev `window.__OPENUI__.events`, so e2e can assert "exactly one
+ * spinRequested fired during the round" without timing guesses (Charter P10/G6).
+ */
+declare class EventLog {
+    private readonly buf;
+    private readonly cap;
+    private readonly clock;
+    private readonly disposers;
+    constructor(bus: EventBus<OpenUIEvents>, opts?: EventLogOptions);
+    private record;
+    /** The most recent payload of `type`, or undefined. */
+    last<K extends keyof OpenUIEvents>(type: K): OpenUIEvents[K] | undefined;
+    /** How many of `type` are in the buffer. */
+    count(type: keyof OpenUIEvents): number;
+    /** Every event at or after timestamp `t`, in order. */
+    since(t: number): LoggedEvent[];
+    clear(): void;
+    dispose(): void;
+}
+
+/**
+ * Currency display metadata + a pure formatter (Charter P11: data, not code).
+ *
+ * Stake Engine supports 35+ currencies — fiat (incl. zero-decimal JPY/KRW/VND…),
+ * crypto, and the social coins XGC/XSC (shown as "GC"/"SC", never locale-formatted
+ * as fiat). A host shouldn't have to hand-tune decimals for each, so this maps a
+ * code → its display precision; anything unknown defaults to 2 (the common case).
+ * The UI computes no money — it only formats what the game sets.
+ */
+
+interface CurrencyInfo {
+    /** Fractional digits to show (JPY/KRW = 0, USD = 2, BTC = 8). */
+    decimals: number;
+    /** Display code shown to the player when it differs from the code (XGC → "GC"). */
+    display?: string;
+    /** A social / sweepstakes coin — never formatted as a fiat currency. */
+    social?: boolean;
+}
+/** Code → display info. Unknown codes fall back to 2 decimals (see {@link resolveCurrency}). */
+declare const CURRENCY_TABLE: Readonly<Record<string, CurrencyInfo>>;
+/** True if `code` is a Stake social/sweepstakes coin (display "GC"/"SC"). */
+declare function isSocialCurrency(code: string): boolean;
+/**
+ * Resolve a currency code to a complete, display-ready {@link CurrencySpec}: fills
+ * decimals from the table (default 2) and maps social coins to their display code.
+ * Anything in `overrides` wins, so a game can still hand-tune. Never throws.
+ */
+declare function resolveCurrency(code: string, overrides?: Partial<CurrencySpec>): CurrencySpec;
+/**
+ * Format an amount (major units) per a {@link CurrencySpec}: grouped integer part,
+ * fixed decimals, the code on the configured side. `signed` adds an explicit "+"
+ * for non-negative values (negatives always show "-") — used by the net-position
+ * readout. Pure + total: a malformed number renders as "0".
+ */
+declare function formatAmount(value: number, spec: CurrencySpec, opts?: {
+    signed?: boolean;
+}): string;
+
+/**
+ * Build / clamp a bet ladder from a Stake Engine RGS bet config so the host doesn't
+ * have to hand-tune `betLadder` (and can't ship a stake outside min/max/step). Pure.
+ */
+interface RgsBetConfig {
+    /** Allowed stake amounts in API minor units (Stake: dollars × 1_000_000). */
+    betLevels?: number[];
+    minBet?: number;
+    maxBet?: number;
+    stepBet?: number;
+    /** Default stake in minor units (custom bets must be a multiple of this). */
+    defaultBetLevel?: number;
+}
+/** Stake's API minor-unit divisor (1_000_000 minor units = 1.00). */
+declare const API_AMOUNT_DIVISOR = 1000000;
+/**
+ * Turn an RGS bet config into a `{ levels, index }` ladder in MAJOR units (what
+ * `UISpec.betLadder` wants). Uses `betLevels` if present, else derives from
+ * min/max/step. `divisor` converts minor→major (default Stake's 1_000_000).
+ */
+declare function buildBetLadder(cfg: RgsBetConfig, divisor?: number): {
+    levels: number[];
+    index: number;
+};
+/** Clamp a stake (major units) to the RGS min/max and snap to `stepBet`. Pure. */
+declare function clampBet(amount: number, cfg: RgsBetConfig, divisor?: number): number;
+
+/**
+ * Win-celebration classifier — the RTS 14F guardrail. open-ui doesn't render the win
+ * (the game does), but this helper lets a game decide HOW LOUD to celebrate without
+ * ever celebrating a return ≤ the stake (the most-fined responsible-gambling rule).
+ */
+interface WinTier {
+    name: string;
+    /** Minimum win/stake multiplier for this tier. */
+    minMultiplier: number;
+}
+/** Default escalation tiers (multipliers of stake). */
+declare const DEFAULT_WIN_TIERS: readonly WinTier[];
+/**
+ * Classify a win for celebration. Returns `'none'` when the win is ≤ the stake (so a
+ * "win" that returns less than was staked is NEVER celebrated — UKGC RTS 14F), else
+ * `'win'` for a positive win below the first tier, or the highest tier whose
+ * multiplier threshold is met. Pure + total.
+ */
+declare function winTier(win: number, stake: number, tiers?: readonly WinTier[]): string;
+
+export { API_AMOUNT_DIVISOR, type Anchor, AutoplayControl, type AutoplayLimits, type AutoplayMode, type AutoplayOptions, BLOCK_KINDS, type BlockFactory, type BlockSpec, type Breakpoint, type BuiltPanel, ButtonControl, type ButtonOptions, CURRENCY_TABLE, CardControl, type CardOptions, type ComposeMenuOptions, Control, type ControlOptions, type ControlOverride, ControlRegistry, type ControlSnapshot, type CurrencyInfo, type CurrencySpec, DEFAULT_MENU_TITLES, DEFAULT_NOTICE_ACTION, DEFAULT_WIN_TIERS, type DeepPartial, DictionaryTranslator, type Dispose, EventBus, EventLog, type EventLogOptions, type EventMap, Fade, type HostHooks, type JurisdictionConfig, type KnownControlId, LOCALE_LABELS, type LayoutConfig, type LayoutSpec, type LoggedEvent, type MenuSpec, type NoticeAction, type NoticeOptions, OpenUI, type OpenUIEvents, type OpenUIOptions, type Orientation, PanelControl, type PanelOptions, type PanelSpec, type PanelVariant, Parallel, type Placement, Pulse, RGS_ERROR_KEYS, ReadoutControl, type ReadoutKind, type ReadoutOptions, type RealityCheckOptions, type Rect, type ResponsiveKey, type ResponsiveOverride, type RgsBetConfig, type RgsErrorCode, type RgsErrorOptions, type ScreenState, SelectControl, type SelectControlOptions, type SelectOption, Sequence, Signal, SliderControl, type SliderOptions, type SpecIssue, SpinControl, type SpinPress, type SpinSpec, Squish, type StateDef, type StateMap, StepperControl, type StepperOptions, type Subscribable, type Theme, type ThemeChoice, type ThemeIssue, type ThemeOverrides, type ThemePreset, ToggleControl, type ToggleOptions, type Transition, type Translator, TurboControl, type TurboOptions, type TurboSpec, Turn, type UISpec, ValueDisplay, type ValueDisplayOptions, type ViewInspect, type WinTier, applyJurisdiction, breakpointFor, buildBetLadder, buildBlocks, buildPanel, buttonBlocks, clampBet, clampDecimals, clampDigits, clampMinDigits, composeMenu, computeScreen, createUI, defaultHudSpec, defaultLayoutConfig, defaultTheme, defineUI, dictionary, displayDigits, effect, errorBlocks, extendTheme, formatAmount, installResponsive, integerDigits, isSafeColor, isSocialCurrency, openuiDefaults, resolveCurrency, resolvePlacement, resolveTheme, resolveTurboModes, safeAmount, sanitizeThemeOverrides, themePresets, validateSpec, valueFitMaxWidth, winTier };