@open-slot-ui/core 0.8.3 → 0.9.0

package/dist/index.d.ts

@@ -503,6 +503,16 @@ declare class ValueDisplay extends Control {
     readonly value: Signal<number>;
     readonly currency: Signal<CurrencySpec>;
     readonly label?: string;
+    /**
+     * Show a value at the precision it ACTUALLY carries (default on): when the value has
+     * more fraction digits than the currency's native precision — a sub-unit win like a
+     * USD 0.01 bet × a ×0.2 face = 0.002, or the 999.982 balance it leaves behind — the
+     * display decimals bump just enough to reveal them ($0.002), and drop back to the
+     * native look (5.00) once the value is clean again. Set `false` for hard-fixed decimals.
+     */
+    autoPrecision: boolean;
+    /** The currency's NATIVE precision — what `autoPrecision` returns to on clean values. */
+    private baseDecimals;
     /** 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`). */
@@ -515,8 +525,13 @@ declare class ValueDisplay extends Control {
      *  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). */
+    /** Keep the prior spec on malformed input; clamp decimals to 0..8 (P11). The given
+     *  decimals become the NATIVE precision (`autoPrecision` bumps above it as needed). */
     setCurrency(spec: CurrencySpec): void;
+    /** Bump the display decimals to what the current value needs — never below the
+     *  currency's native precision — and drop back once the value is clean again.
+     *  No-op (and no signal churn) when the shown precision is already right. */
+    private applyPrecision;
     /** Accent emphasis: the renderer tints the value in the theme accent while on.
      *  For "this number is modified" moments — e.g. a bet display showing the
      *  EFFECTIVE stake while an ante/boost multiplies it. */
@@ -1198,6 +1213,121 @@ declare class DictionaryTranslator implements Translator {
 /** Convenience factory for a zero-dep dictionary translator. */
 declare function dictionary(messages: Record<string, Record<string, string>>, locale: string, socialMessages?: Record<string, Record<string, string>>): DictionaryTranslator;
 
+/**
+ * GAME FACTS + the rules-completeness AUDIT — the "can't forget" layer for the
+ * Info/Rules menu (Charter P11: data, not prose).
+ *
+ * A game declares WHAT IT HAS as structured facts — its math modes (base game, buy
+ * features, bet boosts) with their RTP and max win, its free-spins behavior, its
+ * volatility/cap — via `UISpec.facts` and/or `ui.declareFacts` (the buy-feature modal
+ * declares its configured features automatically). The rules content stays modular
+ * blocks (the "block builder"), and two mechanisms tie the two together:
+ *
+ * 1. The `mode-stats` block AUTO-RENDERS the per-mode RTP / Max-win grid straight
+ *    from the facts — declared once, so the table can never drift from the config.
+ * 2. `auditRules(facts, rules)` checks the rules blocks against the facts and
+ *    reports every REQUIRED declaration that is missing (a mode's RTP or max win,
+ *    an undescribed buy feature) plus the HIGHLY RECOMMENDED ones (free-spins count
+ *    + retrigger policy, the legal disclaimer, a controls guide). The info menu
+ *    renders these findings as an explicit warning card when the rules open — a
+ *    forgotten declaration is stated, never silent.
+ *
+ * Any block may carry `covers: ['rtp:bonus', 'freespins', …]` to mark a topic as
+ * covered by hand-written prose the text heuristics can't see.
+ */
+
+/** One math mode / play mode the game exposes (base · buy feature · bet boost · ante). */
+interface GameModeFact {
+    /** Stable id (matches the buy-feature card / RGS mode id), e.g. `'base'`, `'bonus'`. */
+    id: string;
+    /** Display name, e.g. `'Golden Rush'` — run through `ui.t` (social swaps apply). */
+    name: string;
+    /** What kind of mode this is. `'base'` is the plain game; everything else is a
+     *  configured feature that MUST be described in the rules. */
+    kind?: 'base' | 'buy' | 'boost' | 'ante' | 'bonus';
+    /** Cost as a multiple of the base bet (buy price / per-spin surcharge). */
+    cost?: number;
+    /** The mode's RTP in percent (e.g. 95.5). Required in the rules for every mode. */
+    rtp?: number;
+    /** The mode's maximum win as a multiple of the base bet (e.g. 5000). Required. */
+    maxWinX?: number;
+}
+/** Free-spins behavior — HIGHLY RECOMMENDED to declare (or `false` = game has none). */
+interface FreeSpinsFact {
+    /** How many free spins the bonus awards (e.g. exactly 3). */
+    count?: number;
+    /** Whether free spins can be retriggered during the bonus. */
+    retrigger?: boolean;
+    /** Free-form note (not audited). */
+    note?: string;
+}
+/** Everything the game HAS, declared as data. Drives `mode-stats` + `auditRules`. */
+interface GameFacts {
+    modes?: GameModeFact[];
+    /** Free-spins facts, or `false` to state explicitly the game has none. */
+    freeSpins?: FreeSpinsFact | false;
+    /** Volatility label shown by `mode-stats` (e.g. `'Very high'`). */
+    volatility?: string;
+    /** The overall round win cap (× base bet) shown by `mode-stats` (e.g. 5000). */
+    maxWinCapX?: number;
+}
+/** Merge two facts declarations: modes merge BY ID (defined incoming fields win);
+ *  scalar facts take the incoming value when defined. Pure — never mutates inputs. */
+declare function mergeFacts(base: GameFacts, add: GameFacts): GameFacts;
+/** Format an RTP percent the Stake way: always two decimals (95.5 → "95.50%"). */
+declare function formatRtp(rtp: number): string;
+/** Format a × multiple with thousands grouping (5000 → "5,000×"). */
+declare function formatTimes(x: number): string;
+/**
+ * The auto-generated per-mode stat rows a `mode-stats` block renders: one
+ * `RTP · <mode>` + `Max win · <mode>` pair per declared mode, then Volatility and
+ * the round cap when declared. `tr` localizes the label words + mode names (social
+ * mode swaps "Max win" → "Max prize" via the built-in social dictionary).
+ */
+declare function modeStatsItems(facts: GameFacts | undefined, tr?: (s: string) => string): Array<{
+    label: string;
+    value: string;
+}>;
+/**
+ * The INTERPOLATION VARIABLES the declared facts expose to rules copy — the
+ * "universal interpolatable rules" contract. Any rules text (inline blocks or a
+ * {@link RulesDoc}) may use i18next-style tokens; the info menu resolves them from
+ * the LIVE facts, so a stated RTP / max win / price can never drift from config:
+ *
+ *   `{{rtp.<modeId>}}`     → "95.50%"        `{{maxWin.<modeId>}}` → "5,000×"
+ *   `{{cost.<modeId>}}`    → "185×"          `{{name.<modeId>}}`   → the mode name
+ *   `{{freeSpins.count}}`  → 3               `{{freeSpins.retrigger}}` → "can"/"cannot"
+ *   `{{volatility}}`       → "Very high"     `{{maxWinCap}}`       → "5,000×"
+ *
+ * `extra` merges additional host vars (e.g. `game.name`) on top.
+ */
+declare function factsVars(facts: GameFacts | undefined, extra?: Record<string, string | number>): Record<string, string | number>;
+/** One finding from the rules audit. `required` findings are compliance gaps
+ *  (RTP / max win / an undescribed configured feature); `recommended` are the
+ *  strongly-advised ones (free-spins details, legal disclaimer, controls guide). */
+interface RulesAuditIssue {
+    level: 'required' | 'recommended';
+    /** Machine code, e.g. `'rules-missing-rtp'`, `'facts-missing-maxwin'`. */
+    code: string;
+    /** The coverage topic that would satisfy it, e.g. `'rtp:bonus'`, `'freespins'`. */
+    topic: string;
+    /** Human sentence shown in the info menu's warning card. */
+    message: string;
+}
+/**
+ * Audit the rules blocks against the declared game facts. Pure + never-throw.
+ * Findings come back most severe first (`required`, then `recommended`); an empty
+ * array means the rules declare everything the game's configuration demands.
+ *
+ * `opts.resolve` maps each collected string BEFORE the text heuristics run — pass
+ * the same translate-and-interpolate the renderer uses (`(s) => ui.t(s, factsVars(...))`)
+ * so localized copy and `{{rtp.base}}`-style tokens are audited AS RENDERED: a rules
+ * text that states its RTP via the token is, by construction, always correct.
+ */
+declare function auditRules(facts: GameFacts | undefined, rules: BlockSpec[] | undefined, opts?: {
+    resolve?: (s: string) => string;
+}): RulesAuditIssue[];
+
 interface OpenUIOptions {
     theme?: Theme;
     layout?: LayoutConfig;
@@ -1262,6 +1392,11 @@ declare class OpenUI {
         name?: string;
         version?: string;
     };
+    /** Declared GAME FACTS (modes + RTP/max win, free spins, volatility, cap) — seeded
+     *  from `spec.facts`, extended at runtime via {@link declareFacts} (the buy-feature
+     *  modal declares its configured features automatically). Drives the `mode-stats`
+     *  rules block + the rules-completeness audit in the info menu. */
+    readonly facts: Signal<GameFacts>;
     /** Minimum round duration (ms) from jurisdiction — stored for the GAME to enforce. */
     minimumRoundDuration: number;
     /** Buy-feature confirm threshold, as a multiple of the base bet. A play (buy or
@@ -1269,6 +1404,13 @@ declare class OpenUI {
      *  — Stake requires that bet modes above 2× never activate on a single click. `0`
      *  (the default) = off. Set via `spec.buyFeature.confirmAboveCost` or a jurisdiction. */
     confirmBuyAboveCost: number;
+    /** When autoplay stops while the balance can no longer cover the next round —
+     *  whether the built-in RG enforcement stopped it, the game's own pre-check did, or
+     *  the player pressed Stop already broke — pop the SAME insufficient-funds modal a
+     *  manual spin shows (ERR_IPB) instead of ending silently. A normal stop with funds
+     *  in hand shows nothing. Default on; `spec.autoplay.insufficientFundsNotice: false`
+     *  opts out. */
+    autoplayInsufficientNotice: boolean;
     private sessionNet;
     private prevVolumes;
     /** The frozen UISpec `createUI` built this from, if any — authored = run = tested. */
@@ -1325,6 +1467,9 @@ declare class OpenUI {
      * limits. One feed point powers both `displayNetPosition` and the autoplay stops.
      */
     reportRound(win: number, bet: number): void;
+    /** Merge more game facts into {@link facts} (modes merge by id; defined incoming
+     *  fields win). The info menu re-audits + re-renders its rules automatically. */
+    declareFacts(add: GameFacts): 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.
@@ -1499,8 +1644,15 @@ interface ResponsiveOverride {
  * 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.
+ *
+ * Every block may carry `covers` — rules-audit topic tags (e.g. `'rtp:bonus'`,
+ * `'freespins'`) marking that this block's hand-written prose covers a declaration
+ * the audit's text heuristics can't see. See `auditRules` in `spec/facts`.
  */
 type BlockSpec = {
+    /** Rules-audit topics this block covers (see `auditRules`). */
+    covers?: string[];
+} & ({
     kind: 'slider';
     id: string;
     label?: string;
@@ -1565,6 +1717,13 @@ type BlockSpec = {
         label: string;
         value: string;
     }>;
+} | {
+    kind: 'mode-stats';
+    id: string;
+    extras?: Array<{
+        label: string;
+        value: string;
+    }>;
 } | {
     kind: 'steps';
     id: string;
@@ -1621,9 +1780,9 @@ type BlockSpec = {
     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"];
+declare const BLOCK_KINDS: readonly ["slider", "toggle", "button", "select", "stepper", "value", "text", "heading", "subheading", "callout", "stat-grid", "mode-stats", "steps", "table", "paytable", "image", "media", "cards", "legal", "divider", "group"];
 interface PanelSpec {
     id: string;
     variant: PanelVariant;
@@ -1651,12 +1810,16 @@ interface UISpec {
      * 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.
+     * `insufficientFundsNotice` (default true): when autoplay stops with the balance
+     * unable to cover the next round, show the same insufficient-funds modal a manual
+     * spin shows (ERR_IPB) instead of ending silently.
      */
     autoplay?: {
         options?: number[];
         mode?: AutoplayMode;
         lossLimits?: number[];
         winLimits?: number[];
+        insufficientFundsNotice?: boolean;
     };
     /** Turbo switcher: 2-mode (off/on) or 3-mode (off/turbo/super). */
     turbo?: TurboSpec;
@@ -1702,6 +1865,15 @@ interface UISpec {
         name?: string;
         version?: string;
     };
+    /**
+     * Structured GAME FACTS — what the game HAS: its math modes (base / buy features /
+     * boosts) with RTP + max win, its free-spins behavior, volatility and cap. Drives
+     * the auto `mode-stats` rules block AND the rules-completeness audit: a configured
+     * mode whose RTP / max win / description is missing from the rules is called out
+     * explicitly in the info menu (see `auditRules`). The buy-feature modal declares
+     * its configured features into this automatically (`ui.declareFacts`).
+     */
+    facts?: GameFacts;
     /** Buy-feature / bet-mode confirmation. `confirmAboveCost` (× base bet) makes any
      *  play costing MORE than that require a confirm step before it commits — Stake
      *  requires bet modes above 2× to never activate on a single click, so set `2`.
@@ -1861,6 +2033,60 @@ type Responsive = Partial<Record<ResponsiveKey, ResponsiveOverride>>;
  */
 declare function installResponsive(ui: OpenUI, responsive: Responsive): Dispose;
 
+/**
+ * The UNIVERSAL RULES DOCUMENT — one portable, editable JSON file that carries a
+ * game's whole rules surface: the ordered block list, its i18next-compatible
+ * per-locale messages (flat keys, `{{token}}` interpolation — use i18next with
+ * `keySeparator: false` if you consume them elsewhere), the social/sweepstakes
+ * overrides, and (optionally) the game facts it was authored against.
+ *
+ * Authoring convention: a block's `text` is an i18n KEY (or literal English —
+ * a string is its own key, the house convention); `messages` supplies per-locale
+ * copy; any string may use the `factsVars` tokens (`{{rtp.base}}`,
+ * `{{maxWin.bonus}}`, `{{freeSpins.count}}`, …) which the info menu resolves from
+ * the LIVE declared facts — so stated numbers can never drift from config.
+ *
+ * A game consumes the file with ONE call:
+ *
+ *   import doc from './rules.doc.json';
+ *   const hud = mountHud(app, applyRulesDoc(spec, doc as RulesDoc));
+ *
+ * The stakeplate rules editor (`npx` runnable) reads/writes this exact format and
+ * validates it against `validateSpec` + `auditRules` while you edit.
+ */
+
+interface RulesDoc {
+    /** Format version — currently 1. */
+    version: 1;
+    /** The ordered rules blocks (the same modular `BlockSpec` palette the menu renders). */
+    blocks: BlockSpec[];
+    /** i18next-compatible flat resources per locale (string keys → copy; `{{token}}` ok). */
+    messages?: Record<string, Record<string, string>>;
+    /** Social / sweepstakes wording overrides, same shape, consulted only in social mode. */
+    socialMessages?: Record<string, Record<string, string>>;
+    /** The facts this document was authored against — merged into `spec.facts` (the
+     *  spec's own facts win), and used by editors/CI to run the audit stand-alone. */
+    facts?: GameFacts;
+}
+/** Runtime shape check — never throws. A malformed doc reports false and is skipped. */
+declare function isRulesDoc(doc: unknown): doc is RulesDoc;
+/**
+ * Fold a rules document into a UISpec (pure — returns a NEW spec): the doc's blocks
+ * become `menu.rules`, its messages/socialMessages merge UNDER the spec's own
+ * dictionaries (host copy wins on conflicts), and its facts merge under `spec.facts`.
+ * A malformed doc returns the spec unchanged (never-reject, Charter P11).
+ */
+declare function applyRulesDoc(spec: UISpec, doc: RulesDoc): UISpec;
+/**
+ * Audit a rules document STAND-ALONE (editor / CI use): resolves each string through
+ * the doc's own `locale` messages (default `'en'`) and interpolates the facts tokens,
+ * exactly like the info menu renders it, then runs {@link auditRules}.
+ */
+declare function auditRulesDoc(doc: RulesDoc, opts?: {
+    locale?: string;
+    facts?: GameFacts;
+}): RulesAuditIssue[];
+
 /**
  * The reference HUD expressed as data — the knobs `new OpenUI()` ships with.
  * `createUI(defaultHudSpec)` is byte-equivalent to zero-arg `createUI()` (a test
@@ -1950,6 +2176,26 @@ declare function resolveCurrency(code: string, overrides?: Partial<CurrencySpec>
  * non-negative values (used by the net-position readout). Pure + total: a malformed
  * number renders as "0".
  */
+/**
+ * How many fraction digits a value ACTUALLY uses — never fewer than the currency's
+ * native `base` precision, never more than the 8-decimal ceiling. Snaps float noise
+ * (0.1+0.2) by measuring at 8 dp, then strips trailing zeros back down to `base`.
+ *
+ * Why: Stake requires a currency's FULL bet ladder verbatim from authenticate —
+ * including its true minimum (USD 0.01) — so a win (0.01 bet × a ×0.2 face = 0.002)
+ * or a running balance (999.982) can carry sub-unit precision the currency's fixed
+ * decimals would CROP to "0.00". This tells the display exactly how many digits that
+ * value needs; a clean value keeps the ordinary native look (5.00, 1,000.00).
+ */
+declare function neededDecimals(value: number, base: number): number;
+/**
+ * Format an amount at the precision it actually needs (see {@link neededDecimals}),
+ * so a sub-unit win renders in full ("$0.002") instead of rounding to "$0.00".
+ * Values within the currency's native precision format exactly like {@link formatAmount}.
+ */
+declare function formatAmountPrecise(value: number, spec: CurrencySpec, opts?: {
+    signed?: boolean;
+}): string;
 declare function formatAmount(value: number, spec: CurrencySpec, opts?: {
     signed?: boolean;
 }): string;
@@ -1978,7 +2224,23 @@ declare function buildBetLadder(cfg: RgsBetConfig, divisor?: number): {
     levels: number[];
     index: number;
 };
+/**
+ * Resolve the shown bet ladder from an authenticate response (MAJOR units): use EVERY
+ * level the RGS offers, VERBATIM, and snap the default bet to the matching level.
+ *
+ * Deliberately does NOT filter out low levels. Stake requires every currency's full
+ * ladder — including its true minimum (e.g. USD 0.01) — to come straight from
+ * authenticate. A consequence is that the smallest win can be below one minimal
+ * currency unit (USD 0.01 bet × a ×0.2 face = 0.002); the money displays render that
+ * true sub-unit amount (see `formatAmountPrecise` / `ValueDisplay.autoPrecision`)
+ * rather than hiding the level. Pure — share it between the UISpec builder and the
+ * game's balance store so both agree on the bet.
+ */
+declare function resolveBetLadder(availableBets: number[] | undefined, defaultBet: number, fallback?: 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;
 
-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, type DeepPartial, DictionaryTranslator, type Dispose, EventBus, EventLog, type EventLogOptions, type EventMap, Fade, type ForbiddenMatch, 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 SocialPhraseIssue, type SoundControls, type SpecIssue, SpinControl, type SpinPress, type SpinSpec, Squish, type StageRect, 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, applyJurisdiction, breakpointFor, buildBetLadder, buildBlocks, buildPanel, buttonBlocks, checkSocialPhrases, clampBet, clampDecimals, clampDigits, clampMinDigits, collectSocialCopy, composeMenu, computeScreen, createUI, defaultHudSpec, defaultLayout, defaultLayoutConfig, defaultTheme, defineUI, dictionary, displayDigits, effect, errorBlocks, extendTheme, findForbiddenPhrases, formatAmount, installResponsive, integerDigits, isSafeColor, isSocialCurrency, landscapeDefaultLayouts, openuiDefaults, openuiSocialDefaults, portraitDefaultLayouts, resolveCurrency, resolvePlacement, resolveTheme, resolveTurboModes, safeAmount, sanitizeThemeOverrides, themePresets, validateSpec, valueFitMaxWidth };
+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, type DeepPartial, DictionaryTranslator, type Dispose, EventBus, EventLog, type EventLogOptions, type EventMap, Fade, type ForbiddenMatch, type FreeSpinsFact, type GameFacts, type GameModeFact, 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 RulesAuditIssue, type RulesDoc, type ScreenState, SelectControl, type SelectControlOptions, type SelectOption, Sequence, Signal, SliderControl, type SliderOptions, type SocialPhraseIssue, type SoundControls, type SpecIssue, SpinControl, type SpinPress, type SpinSpec, Squish, type StageRect, 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, applyJurisdiction, applyRulesDoc, auditRules, auditRulesDoc, breakpointFor, buildBetLadder, buildBlocks, buildPanel, buttonBlocks, checkSocialPhrases, clampBet, clampDecimals, clampDigits, clampMinDigits, collectSocialCopy, composeMenu, computeScreen, createUI, defaultHudSpec, defaultLayout, defaultLayoutConfig, defaultTheme, defineUI, dictionary, displayDigits, effect, errorBlocks, extendTheme, factsVars, findForbiddenPhrases, formatAmount, formatAmountPrecise, formatRtp, formatTimes, installResponsive, integerDigits, isRulesDoc, isSafeColor, isSocialCurrency, landscapeDefaultLayouts, mergeFacts, modeStatsItems, neededDecimals, openuiDefaults, openuiSocialDefaults, portraitDefaultLayouts, resolveBetLadder, resolveCurrency, resolvePlacement, resolveTheme, resolveTurboModes, safeAmount, sanitizeThemeOverrides, themePresets, validateSpec, valueFitMaxWidth };