@hizi.io/engine-sdk 0.1.9

package/lib/types/blackjack.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Blackjack-specific payloads carried through `IPlaceBetOptions.additionalData`
+ * and returned in `IGameResult.scenario`.
+ *
+ * The full round — engine state, current hands, dealer view, available
+ * actions, side bets, totals — lives flat on `result.scenario`. Whether the
+ * round is still active is signalled by `engineData.inProgress` on the
+ * parent `IGameResult`. Rules switches are shipped once via `loadConfig` and
+ * are not echoed on every placeBet.
+ */
+export type TBlackjackRank = 'A' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | 'J' | 'Q' | 'K';
+export type TBlackjackSuit = 'S' | 'H' | 'D' | 'C';
+export interface IBlackjackCard {
+    rank: TBlackjackRank;
+    suit: TBlackjackSuit;
+}
+export type TBlackjackAction = {
+    kind: 'hit';
+} | {
+    kind: 'stand';
+} | {
+    kind: 'double';
+} | {
+    kind: 'split';
+} | {
+    kind: 'insurance';
+    amount: number;
+} | {
+    kind: 'evenMoney';
+};
+export type TBlackjackActionKind = TBlackjackAction['kind'];
+export interface IBlackjackSideBets {
+    perfectPairs?: {
+        stake: number;
+    };
+    twentyOnePlusThree?: {
+        stake: number;
+    };
+}
+export interface IBlackjackInitialBet {
+    /** Base stake for the main hand. */
+    stake: number;
+    /** Optional side bets placed with the initial deal. */
+    sideBets?: IBlackjackSideBets;
+}
+/**
+ * One legal action presented to the player while the round is in progress.
+ * Surfaced in `IBlackjackScenario.availableActions`. Empty once settled.
+ */
+export interface IBlackjackChoice {
+    action: TBlackjackActionKind;
+    /** Extra stake the player must post to take this action (double, split, insurance). */
+    supplementalStakeCost?: number;
+    data?: Record<string, unknown>;
+}
+/**
+ * One player hand. `total`/`soft` are kept in sync with `cards` so the client
+ * never has to recompute them. All boolean flags are optional — missing
+ * means false. `outcome`/`payout` populate at settlement.
+ */
+export interface IBlackjackHand {
+    cards: IBlackjackCard[];
+    total: number;
+    /** True when an ace is currently counted as 11 in `total`. Omitted when false. */
+    soft?: boolean;
+    stake: number;
+    isFromSplit?: boolean;
+    isFromSplitAces?: boolean;
+    busted?: boolean;
+    stood?: boolean;
+    doubled?: boolean;
+    surrendered?: boolean;
+    outcome?: 'win' | 'loss' | 'push' | 'blackjack' | 'bust' | 'surrender';
+    payout?: number;
+}
+export interface IBlackjackDealer {
+    upcard: IBlackjackCard;
+    /**
+     * Records the dealer-peek result without revealing the hole rank.
+     * Omitted when no peek was performed.
+     *  - 'noBJ' : peeked, no blackjack — round continues.
+     *  - 'bj'   : peeked, dealer has blackjack — round terminates immediately.
+     */
+    peekState?: 'noBJ' | 'bj';
+    /** Full revealed dealer hand, present only at settlement. */
+    cards?: IBlackjackCard[];
+    /** Final dealer total, present only at settlement. */
+    total?: number;
+}
+export interface IBlackjackPerfectPairsBet {
+    stake: number;
+    /** Present only at settlement. */
+    result?: 'mixed' | 'colored' | 'perfect' | 'loss';
+    /** Present only at settlement. */
+    payout?: number;
+}
+export interface IBlackjackTwentyOnePlusThreeBet {
+    stake: number;
+    result?: 'flush' | 'straight' | 'threeOfAKind' | 'straightFlush' | 'suitedTrips' | 'loss';
+    payout?: number;
+}
+export interface IBlackjackInsuranceBet {
+    stake: number;
+    won?: boolean;
+    payout?: number;
+}
+/**
+ * The round shape returned in `result.scenario`.
+ *
+ * Settlement-only fields (`dealer.cards`, `dealer.total`, each hand's
+ * `outcome`/`payout`, side-bet `result`/`payout`, `insurance.won`/`payout`,
+ * `capped`/`uncappedTotalWin`) are absent mid-round and populated once the
+ * round terminates. Mid-round-only fields (`activeHand`, `phase`,
+ * `availableActions`) are dropped at settlement.
+ *
+ * Use `engineData.inProgress` to gate continuation calls; `phase` carries
+ * the finer-grained sub-state (`insurance_offered` vs `player_turn`) while
+ * the round is active.
+ */
+export interface IBlackjackScenario {
+    dealer: IBlackjackDealer;
+    hands: IBlackjackHand[];
+    /** Index into `hands` of the hand the player is currently acting on. Omitted once the round is settled. */
+    activeHand?: number;
+    /**
+     * Sub-state of the player's decision while the round is in progress.
+     * Omitted once settled — use `engineData.inProgress` for round liveness.
+     */
+    phase?: 'insurance_offered' | 'player_turn';
+    /** Legal next-action list — present only when there is a decision to make. */
+    availableActions?: IBlackjackChoice[];
+    /** Each entry present only when that bet was placed. Whole field omitted when no side bets. */
+    sideBets?: {
+        perfectPairs?: IBlackjackPerfectPairsBet;
+        twentyOnePlusThree?: IBlackjackTwentyOnePlusThreeBet;
+    };
+    insurance?: IBlackjackInsuranceBet;
+    /** True only when the player took even money. Omitted otherwise. */
+    evenMoneyTaken?: boolean;
+    baseStake: number;
+    /**
+     * Base stake + every supplemental posted so far. Individual stake amounts
+     * are recoverable from `insurance.stake`, `sideBets.*.stake`, and each
+     * hand's `stake`. The running supplemental total is `totalStake - baseStake`.
+     */
+    totalStake: number;
+    /** 0 mid-round; gross payout once settled. */
+    totalWin: number;
+    /** Set when the configured `maxRoundWin` clipped the gross payout. */
+    capped?: boolean;
+    /** Pre-cap gross payout, present only when `capped` is true. */
+    uncappedTotalWin?: number;
+}
+/** Build a `placeBet` additionalData payload for the initial bet of a blackjack round. */
+export declare function blackjackInitialData(sideBets?: IBlackjackSideBets): {
+    initialData: {
+        sideBets?: IBlackjackSideBets;
+    };
+};
+/** Build a `placeBet` additionalData payload for a blackjack continuation (action). */
+export declare function blackjackActionData(action: TBlackjackAction): {
+    action: TBlackjackAction;
+};

package/lib/types/blackjack.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Blackjack-specific payloads carried through `IPlaceBetOptions.additionalData`
+ * and returned in `IGameResult.scenario`.
+ *
+ * The full round — engine state, current hands, dealer view, available
+ * actions, side bets, totals — lives flat on `result.scenario`. Whether the
+ * round is still active is signalled by `engineData.inProgress` on the
+ * parent `IGameResult`. Rules switches are shipped once via `loadConfig` and
+ * are not echoed on every placeBet.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blackjackInitialData = blackjackInitialData;
+exports.blackjackActionData = blackjackActionData;
+/** Build a `placeBet` additionalData payload for the initial bet of a blackjack round. */
+function blackjackInitialData(sideBets) {
+    return { initialData: sideBets ? { sideBets } : {} };
+}
+/** Build a `placeBet` additionalData payload for a blackjack continuation (action). */
+function blackjackActionData(action) {
+    return { action };
+}

package/lib/types/buyFeatureOption.d.ts

@@ -0,0 +1,11 @@
+/** Describes an available buy-feature (direct purchase of a bonus feature). */
+export interface IBuyFeatureOption {
+    /** Feature name referencing the feature's DB (e.g. "freespin"). */
+    feature: string;
+    /** Buy price as a multiplier of stake (e.g. 100 means cost = 100 x stake). */
+    price: number;
+    /** Expected return percentage when buying this feature. */
+    featureRTP: number;
+    /** Spins awarded on initial trigger. */
+    initialSpins: number;
+}

package/lib/types/buyFeatureOption.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/collectOptions.d.ts

@@ -0,0 +1,8 @@
+import type { ISessionOptions } from './sessionOptions.js';
+/** Options for the {@link collect} call. */
+export interface ICollectOptions extends ISessionOptions {
+    /** Amount to collect. Omit to collect the full available amount. */
+    amount?: number;
+    /** Additional game-specific parameters (e.g. crash `betHash`). */
+    additionalData?: Record<string, unknown>;
+}

package/lib/types/collectOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/crash.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Crash payloads exchanged with foe-engine.
+ *
+ * Crash is a real-time game driven by websocket events:
+ *
+ *   1. Client calls `placeBet` with one or more bets (each may carry an
+ *      `autoCashOutMultiplier`). The engine opens the round, debits the
+ *      total stake, and returns immediately.
+ *   2. The engine ticks the curve (`timerIntervalMs`, default 90 ms) and
+ *      broadcasts `roundTick` events with the live multiplier. Bets with
+ *      an `autoCashOutMultiplier` settle automatically when the curve
+ *      crosses their target.
+ *   3. The client calls `collect` with a `betHash` (or array of hashes)
+ *      to cash a manual bet at the current live multiplier.
+ *   4. When the curve reaches the committed bust point or every bet has
+ *      cashed out and the post-cashout flight window expires, the engine
+ *      broadcasts `roundEnded` followed by `balanceUpdated` and ends the
+ *      round.
+ *
+ * If the client reconnects mid-round and calls `placeBet` again with the
+ * same token, the engine emits `roundResumed` instead of opening a new
+ * round — the existing round, bets and curve are preserved.
+ *
+ * Each event arrives over the websocket as `{ event, payload }`. The
+ * committed crash multiplier is never returned to the client.
+ */
+/** A single bet posted to `placeBet`. */
+export interface ICrashBetRequest {
+    /** Stake in minor currency units. */
+    stake: number;
+    /** Decimal target multiplier (e.g. 2.5 = 2.5x). Must be > 1. Omit for manual cashout. */
+    autoCashOutMultiplier?: number;
+}
+/** Bet record persisted in `IGameResult.scenario.betsSubmitted`. */
+export interface ICrashBet {
+    /** Engine-assigned hash. Use this to cash out via {@link crashCollectData}. */
+    hash: string;
+    stake: number;
+    /** Decimal target if the bet was placed with an auto-cashout. */
+    autoCashOutMultiplier?: number;
+    /** Multiplier the bet ultimately cashed out at, once settled. */
+    multiplierCollected?: number;
+    /** Win amount in minor currency units, once settled. */
+    amountCollected?: number;
+    collected?: boolean;
+    /** Set briefly while a cashout is in flight. */
+    inProgress?: boolean;
+    /** Milliseconds since round `startTime` when the cashout landed. */
+    collectedAtinMS?: number;
+}
+/** The scenario returned in `IGameResult.scenario` on the round-opening entry. */
+export interface ICrashScenario {
+    /** ISO-8601 timestamp marking when the curve started ticking. */
+    startTime: string;
+    /** Bets posted on `placeBet`, in submission order. */
+    betsSubmitted: ICrashBet[];
+    /** Cashouts keyed by bet hash, populated as bets settle. */
+    betsCollected?: Record<string, {
+        multiplier: number;
+        amount: number;
+    }>;
+}
+/**
+ * Engine `loadConfig` block surfaced through `ILoadConfigReply.config.loadConfig`.
+ * Mirrors the creator-side `CrashConfig` (less the human-friendly `name`).
+ */
+export interface ICrashLoadConfig {
+    /** Multiplier emitted at t=0 of the curve (1 = 1.00x). */
+    startMultiplier: number;
+    /** Curve resolution / broadcast tick rate in ms. */
+    timerIntervalMs: number;
+    /** Idle delay after `placeBet` before the curve starts climbing (ms). */
+    startGameDelayMs: number;
+    /** Target RTP as a fraction (0.95 = 95%). */
+    gameRtp: number;
+    /** Floor for the drawn crash multiplier (decimal, e.g. 1 = insta-bust). */
+    minMultiplier: number;
+    /** Hard payout cap. The drawn multiplier is clamped to this value. */
+    maxMultiplier: number;
+    /** Per-second exponential growth of the curve. */
+    growth: number;
+    /** Time-scale factor applied to the curve once every bet is collected (e.g. 5 = 5× normal speed). */
+    postCashoutSpeedMultiplier: number;
+}
+/** Names of the events emitted over the websocket during a crash round. */
+export type TCrashEventName = 'roundStarted' | 'roundResumed' | 'roundTick' | 'betCashedOut' | 'roundEnded' | 'balanceUpdated';
+/** Sent once per round when the engine has opened the round and the curve is about to tick. */
+export interface ICrashRoundStartedPayload {
+    /** Always 0 — emitted before the first tick. */
+    currentMultiplier: 0;
+    balance?: number;
+    /** Hashes for every bet posted, in the same order as `bets`. */
+    betHashes: string[];
+    /** Engine round id (also returned as `gameRound` on the placeBet reply). */
+    roundHash: string;
+}
+/**
+ * Sent in response to a `placeBet` made against an already-open round (the
+ * client reconnected mid-flight). Carries enough state for the client to
+ * rebuild the round view without waiting for the next `roundTick`.
+ *
+ * The committed bust multiplier is intentionally absent — it is never
+ * revealed before the round ends.
+ */
+export interface ICrashRoundResumedPayload {
+    /** Decimal live multiplier at the moment of resume. */
+    currentMultiplier: number;
+    /** ISO-8601 timestamp of when the curve started ticking. */
+    startTime: string;
+    /** Engine round id. */
+    roundHash: string;
+    /**
+     * Bets opened on the original `placeBet`, with `collected` / `multiplierCollected` /
+     * `amountCollected` populated for any that have already settled.
+     */
+    betsSubmitted: ICrashBet[];
+    /** Current total winnings on this round (minor units). */
+    totalWinValue: number;
+}
+/** Sent every `timerIntervalMs` while the curve is climbing. */
+export interface ICrashRoundTickPayload {
+    /** Decimal live multiplier. */
+    currentMultiplier: number;
+}
+/** Sent after one or more bets settle (auto or manual). */
+export interface ICrashBetCashedOutPayload {
+    /** Highest cashout multiplier in this batch. */
+    multiplier: number;
+    /** Hashes for the bets that just settled. */
+    betHashes: string[];
+    /** Cumulative round winnings after this batch (minor units). */
+    totalWinValue: number;
+    /** Per-bet win amounts in `betHashes` order (minor units). */
+    winValues: number[];
+    /** Sum of `winValues` (minor units). */
+    winValue: number;
+    /** `true` when triggered by an auto-cashout, `false` for a manual `collect`. */
+    isAuto: boolean;
+}
+/** Sent when the curve reaches the committed bust point. */
+export interface ICrashRoundEndedPayload {
+    /** Decimal multiplier the round ended at (== committed bust multiplier). */
+    currentMultiplier: number;
+}
+/** Sent immediately after `roundEnded`. */
+export interface ICrashBalanceUpdatedPayload {
+    /** Cumulative round winnings (minor units). */
+    totalWinValue: number;
+    /** Per-bet credits in arbitrary order. */
+    winValues: Array<{
+        hash: string;
+        value: number;
+    }>;
+}
+/** Discriminated union of crash websocket events. */
+export type TCrashEvent = {
+    event: 'roundStarted';
+    payload: ICrashRoundStartedPayload;
+} | {
+    event: 'roundResumed';
+    payload: ICrashRoundResumedPayload;
+} | {
+    event: 'roundTick';
+    payload: ICrashRoundTickPayload;
+} | {
+    event: 'betCashedOut';
+    payload: ICrashBetCashedOutPayload;
+} | {
+    event: 'roundEnded';
+    payload: ICrashRoundEndedPayload;
+} | {
+    event: 'balanceUpdated';
+    payload: ICrashBalanceUpdatedPayload;
+};
+/**
+ * Named constants for the crash event names. Prefer these over inline
+ * string literals so a rename surfaces as a compile error at every consumer.
+ */
+export declare const CRASH_EVENTS: {
+    readonly ROUND_STARTED: "roundStarted";
+    readonly ROUND_RESUMED: "roundResumed";
+    readonly ROUND_TICK: "roundTick";
+    readonly BET_CASHED_OUT: "betCashedOut";
+    readonly ROUND_ENDED: "roundEnded";
+    readonly BALANCE_UPDATED: "balanceUpdated";
+};
+/**
+ * Build a `placeBet` additionalData payload for a crash round.
+ *
+ * Pass one bet per simultaneous wager. Bets with an `autoCashOutMultiplier`
+ * settle automatically when the curve crosses their target; bets without one
+ * must be cashed out manually via {@link crashCollectData}.
+ *
+ * @example
+ * ```ts
+ * await placeBet({
+ *   backendURL,
+ *   token,
+ *   additionalData: crashPlaceBetData([
+ *     { stake: 100, autoCashOutMultiplier: 2.5 },
+ *     { stake: 100 },
+ *   ]),
+ * });
+ * ```
+ */
+export declare function crashPlaceBetData(bets: ICrashBetRequest[]): {
+    bets: ICrashBetRequest[];
+};
+/**
+ * Build a `collect` additionalData payload to manually cash out one or more bets
+ * at the live curve multiplier.
+ *
+ * @param betHash A single bet hash or an array of hashes (from `roundStarted`
+ *   or `scenario.betsSubmitted`).
+ *
+ * @example
+ * ```ts
+ * await collect({ backendURL, token, additionalData: crashCollectData(betHash) });
+ * ```
+ */
+export declare function crashCollectData(betHash: string | string[]): {
+    betHash: string | string[];
+};

package/lib/types/crash.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Crash payloads exchanged with foe-engine.
+ *
+ * Crash is a real-time game driven by websocket events:
+ *
+ *   1. Client calls `placeBet` with one or more bets (each may carry an
+ *      `autoCashOutMultiplier`). The engine opens the round, debits the
+ *      total stake, and returns immediately.
+ *   2. The engine ticks the curve (`timerIntervalMs`, default 90 ms) and
+ *      broadcasts `roundTick` events with the live multiplier. Bets with
+ *      an `autoCashOutMultiplier` settle automatically when the curve
+ *      crosses their target.
+ *   3. The client calls `collect` with a `betHash` (or array of hashes)
+ *      to cash a manual bet at the current live multiplier.
+ *   4. When the curve reaches the committed bust point or every bet has
+ *      cashed out and the post-cashout flight window expires, the engine
+ *      broadcasts `roundEnded` followed by `balanceUpdated` and ends the
+ *      round.
+ *
+ * If the client reconnects mid-round and calls `placeBet` again with the
+ * same token, the engine emits `roundResumed` instead of opening a new
+ * round — the existing round, bets and curve are preserved.
+ *
+ * Each event arrives over the websocket as `{ event, payload }`. The
+ * committed crash multiplier is never returned to the client.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRASH_EVENTS = void 0;
+exports.crashPlaceBetData = crashPlaceBetData;
+exports.crashCollectData = crashCollectData;
+/**
+ * Named constants for the crash event names. Prefer these over inline
+ * string literals so a rename surfaces as a compile error at every consumer.
+ */
+exports.CRASH_EVENTS = {
+    ROUND_STARTED: 'roundStarted',
+    ROUND_RESUMED: 'roundResumed',
+    ROUND_TICK: 'roundTick',
+    BET_CASHED_OUT: 'betCashedOut',
+    ROUND_ENDED: 'roundEnded',
+    BALANCE_UPDATED: 'balanceUpdated',
+};
+/**
+ * Build a `placeBet` additionalData payload for a crash round.
+ *
+ * Pass one bet per simultaneous wager. Bets with an `autoCashOutMultiplier`
+ * settle automatically when the curve crosses their target; bets without one
+ * must be cashed out manually via {@link crashCollectData}.
+ *
+ * @example
+ * ```ts
+ * await placeBet({
+ *   backendURL,
+ *   token,
+ *   additionalData: crashPlaceBetData([
+ *     { stake: 100, autoCashOutMultiplier: 2.5 },
+ *     { stake: 100 },
+ *   ]),
+ * });
+ * ```
+ */
+function crashPlaceBetData(bets) {
+    return { bets };
+}
+/**
+ * Build a `collect` additionalData payload to manually cash out one or more bets
+ * at the live curve multiplier.
+ *
+ * @param betHash A single bet hash or an array of hashes (from `roundStarted`
+ *   or `scenario.betsSubmitted`).
+ *
+ * @example
+ * ```ts
+ * await collect({ backendURL, token, additionalData: crashCollectData(betHash) });
+ * ```
+ */
+function crashCollectData(betHash) {
+    return { betHash };
+}

package/lib/types/freePlayInfo.d.ts

@@ -0,0 +1,11 @@
+/** Describes operator-granted free plays (free spin tickets). */
+export interface IFreePlayInfo {
+    /** ISO 4217 currency code for the free play. */
+    currency: string;
+    /** Fixed stake amount for each free play. */
+    stake: number;
+    /** Number of free plays available. */
+    count: number;
+    /** Optional feature to enter directly (e.g. "freespin"). */
+    feature?: string;
+}

package/lib/types/freePlayInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/gameResult.d.ts

@@ -0,0 +1,48 @@
+import type { IScenarioInfo } from './scenarioInfo.js';
+import type { ISpinInfo } from './spinInfo.js';
+import type { TPlayerChoiceAward } from './spinAward.js';
+import type { IProgressionEvent } from './progressionCounter.js';
+/**
+ * Primary game result returned by `placeBet()`.
+ * Contains the game-specific scenario data and engine state needed
+ * to render the outcome and determine the next action.
+ *
+ * `entryIndex` / `scenarioInfo` / `spinInfo` etc. are produced by the
+ * fixed-odds (entries-DB) pipeline. Rules-engine games (blackjack, crash,
+ * etc.) derive their result live from RNG and player input — those fields
+ * are not meaningful for them and are omitted from the response.
+ */
+export interface IGameResult {
+    /** Game-specific result data (cast to your game's type for type safety). */
+    scenario: Record<string, unknown>;
+    /** Engine state controlling round progression. */
+    engineData: {
+        /** Index of the selected entry in the game database. Fixed-odds only. */
+        entryIndex?: number;
+        /** Multi-result scenario progression state. Fixed-odds only. */
+        scenarioInfo?: IScenarioInfo;
+        /** Active feature spin counters. Present when feature spins are in play. */
+        spinInfo?: Array<ISpinInfo>;
+        /** Pending player choice options. Present when the engine awaits player input. Each option is either a feature-spin award or a cash award (discriminated by the presence of `winMultiplier` vs `feature`/`count`). */
+        playerChoice?: TPlayerChoiceAward[];
+        /** The feature DB that produced this result. Absent during base game spins. */
+        currentFeature?: string;
+        /** Feature DB for the next spin. Absent when the round is ending. */
+        nextFeature?: string;
+        /** Progression counter values reflecting state at the current scenario step.
+         *  For multi-result scenarios this advances per `placeBet` continuation as the
+         *  step's per-scenario `progressionAwards` are applied. Present when the game
+         *  has progression counters configured. */
+        progressionCounters?: Record<string, number>;
+        /** Progression events that fired at the current scenario step (increments and
+         *  any resolved threshold-crossing awards). Absent or empty when nothing
+         *  happened on this step. */
+        progressionEvents?: IProgressionEvent[];
+        /** Whether the player can call `collect()` right now to cash out. */
+        canCollect?: boolean;
+        /** Whether more `placeBet` calls are needed to complete this round. */
+        inProgress: boolean;
+    };
+    /** Cumulative win as a multiplier of stake. */
+    totalWin: number;
+}

package/lib/types/gameResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/gameRoundInfo.d.ts

@@ -0,0 +1,19 @@
+/** Metadata about the current game round's lifecycle. */
+export interface IGameRoundInfo {
+    /** Unique identifier for this game round. */
+    hash: string;
+    /** Round status: "open" (can collect/wager) or "closed" (round ended). */
+    status: string;
+    /** Stake amount for this round. */
+    stake: number;
+    /** Base stake before, not including buy feature costs. */
+    baseStake: number;
+    /** Game mode identifier. */
+    mode: string;
+    /** ISO 4217 currency code. */
+    currency: string;
+    /** Game code this round belongs to. */
+    game: string;
+    /** Optional multiplier applied to stakes for this player's currency. */
+    currencyMultiplier?: number;
+}

package/lib/types/gameRoundInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });