@energy8platform/game-engine 0.20.0 → 0.21.0

package/dist/slot.d.ts

@@ -106,7 +106,10 @@ interface DecorationConfig {
 }
 interface ReelGridConfig {
     cols: number;
+    /** Uniform row count. Ignored per-reel when `rowsPerReel` is provided. */
     rows: number;
+    /** Per-reel row counts for Megaways / variable-height reels. Length must equal `cols`. */
+    rowsPerReel?: number[];
     cellSize: number;
     gap?: number;
     resolve: SymbolResolver;
@@ -114,23 +117,40 @@ interface ReelGridConfig {
     decoration?: DecorationConfig;
     mask?: boolean;
 }
+/**
+ * A grid of `SymbolCell`s. Supports uniform grids and variable-height reels (Megaways):
+ * when `rowsPerReel` is set each reel is vertically centred inside the tallest reel's envelope.
+ */
 declare class ReelGrid extends Container {
     readonly __uiComponent: true;
     private _cols;
-    private _rows;
+    private _rowsPerReel;
+    private _maxRows;
     private _cellSize;
     private _gap;
     private _cells;
     private _cellLayer;
+    private _resolve;
+    private _frameStyle?;
+    private _mask;
     constructor(config: ReelGridConfig);
+    private _buildCells;
+    private _applyMask;
     get cols(): number;
+    /** Tallest reel's row count (the grid's visual height in rows). */
     get rows(): number;
+    get cellSize(): number;
+    rowsOf(col: number): number;
+    get rowsPerReel(): number[];
+    /** Cell centre position. Variable-height reels are centred in the max-rows envelope. */
     cellPosition(col: number, row: number): {
         x: number;
         y: number;
     };
     getCell(col: number, row: number): SymbolCell;
     setGrid(cells: CellData[][]): void;
+    /** Rebuild the grid with new per-reel row counts (Megaways re-roll / dynamic rows). */
+    reshape(rowsPerReel: number[]): void;
     resize(cellSize: number): void;
 }
 
@@ -204,7 +224,7 @@ interface ReelSpinTimings {
     stopStagger: number;
     settle: number;
 }
-interface ReelStopPlan {
+interface ReelStopPlan$1 {
     reel: number;
     stopTime: number;
     landing: CellData[];
@@ -221,7 +241,7 @@ declare class ReelSpinController {
     /** PURE: per-reel stop timing + landing window. No Pixi mutation. */
     plan(data: ReelSpinData, opts?: {
         turbo?: boolean;
-    }): ReelStopPlan[];
+    }): ReelStopPlan$1[];
     /** Execute the spin: scroll each reel, decelerate, land on target, settle-bounce. Not unit-tested. */
     run(data: ReelSpinData, opts?: {
         turbo?: boolean;
@@ -230,6 +250,536 @@ declare class ReelSpinController {
     skip(): void;
 }
 
+type EasingFunction = (t: number) => number;
+
+/** Resolve a descriptor's string easing name to the engine's easing function. */
+declare const EASING_BY_NAME: Record<string, EasingFunction>;
+/** Resolve an easing name to a function, falling back to easeOutQuad. */
+declare function easingByName(name?: string): EasingFunction;
+
+/** Names of easing functions available in the engine's `Easing` map (see anim/easing-map.ts). */
+type EasingName = 'linear' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic' | 'easeInBack' | 'easeOutBack' | 'easeInOutBack' | 'easeOutBounce' | 'easeInBounce' | 'easeOutElastic' | 'easeInSine' | 'easeOutSine' | 'easeInOutSine';
+/** Win-evaluation model. Purely presentational here (affects geometry + highlight), the math lives in Lua. */
+type EvaluationMode = 'lines' | 'ways' | 'anywhere' | 'cluster' | 'megaways' | 'infinity';
+interface GridConfig {
+    cols: number;
+    /** Uniform row count. Ignored when `rowsPerReel` is set. */
+    rows: number;
+    /** Per-reel row counts (Megaways / variable-height reels). Length should equal `cols`. */
+    rowsPerReel?: number[];
+    cellSize: number;
+    gap: number;
+    evaluation: EvaluationMode;
+    /** For Megaways: clamp per-reel rows to [minRows, maxRows]. */
+    minRows?: number;
+    maxRows?: number;
+    /** Megaways top horizontal reel (renders above the grid, adds to ways). */
+    topReel?: {
+        size: number;
+    } | null;
+    mask: boolean;
+    frameStyle?: CellFrameStyle;
+    decoration?: {
+        padding?: number;
+    };
+}
+type MotionStyle = 'swap' | 'strip' | 'cascade-drop';
+type StopMode = 'sequential' | 'sync' | 'random';
+type StopOrder = 'ltr' | 'rtl';
+type Intensity = 'full' | 'reduced' | 'minimal';
+interface SettleConfig {
+    /** Overshoot amplitude in px applied to the reel before it springs back. */
+    amp: number;
+    ms: number;
+    easing: EasingName;
+}
+/** Squash & stretch on landing impact (Stone-Rush / magnus style). */
+interface SquashConfig {
+    enabled: boolean;
+    scaleX: number;
+    scaleY: number;
+    ms: number;
+}
+interface BlurConfig {
+    enabled: boolean;
+    /** Alpha applied to in-motion symbols (hot-ross uses 0.82). */
+    alpha: number;
+    /** Runtime BlurFilter strength factor (PixiJS slots demo uses ~8), 0 disables the filter. */
+    strength: number;
+    /** Draw vertical motion streaks behind moving symbols. */
+    streaks: boolean;
+}
+interface MotionConfig {
+    style: MotionStyle;
+    /** Base spin-up duration (ms) before the first reel can stop. */
+    spinUp: number;
+    /** Extra hold (ms) at full speed before deceleration. */
+    hold: number;
+    /** Delay (ms) between consecutive reel stops in sequential mode. */
+    stopStagger: number;
+    stopMode: StopMode;
+    stopOrder: StopOrder;
+    settle: SettleConfig;
+    squash: SquashConfig;
+    blur: BlurConfig;
+    /** Multiply all durations in turbo mode (0.5 = twice as fast). */
+    turboFactor: number;
+    /** Global animation-intensity scale (accessibility): full=1, reduced=0.7, minimal=0.4. */
+    intensity: Intensity;
+    /** Allow slam/quick-stop (snaps reels to target without changing outcome). */
+    slamStop: boolean;
+    /** Symbols visible on a reel tape while spinning (swap/strip). */
+    symbolsPerReel: number;
+}
+interface AnticipationConfig {
+    enabled: boolean;
+    /** Symbols that count toward the anticipation threshold (scatter/bonus). */
+    triggerSymbols: string[];
+    /** Number of trigger symbols already landed that arms anticipation (N−1, usually 2). */
+    threshold: number;
+    /** Which reels get the slow treatment: the still-spinning trailing reels, or explicit indices. */
+    reels: 'trailing' | number[];
+    /** Multiply the trailing reel's spin speed (lower = slower / longer). */
+    slowdownFactor: number;
+    /** Extra hold (ms) before the final anticipation reel lands (300–500 typical). */
+    holdMs: number;
+    /** Optional grid zoom while anticipating (magnum-opus uses 1.3×). */
+    zoom: {
+        enabled: boolean;
+        scale: number;
+        ms: number;
+    };
+}
+interface CascadeConfig {
+    enabled: boolean;
+    /** Animate surviving symbols sliding down into the gaps (true tumble). */
+    gravity: boolean;
+    timings: {
+        reveal: number;
+        highlight: number;
+        remove: number;
+        drop: number;
+        refill: number;
+        wait: number;
+    };
+    easings: {
+        highlight: EasingName;
+        remove: EasingName;
+        drop: EasingName;
+    };
+    /** Slow each successive cascade step to build tension: factor = 1 + step*perStepDecel (capped). */
+    perStepDecel: number;
+    perStepDecelCap: number;
+    /** Dim non-winning symbols during the highlight phase. */
+    dimNonWinners: boolean;
+    dimAlpha: number;
+    /** Running win multiplier that climbs per cascade (Pragmatic Tumble / Avalanche). */
+    multiplier: {
+        enabled: boolean;
+        start: number;
+        /** 'add' → +step each step; 'mul' → ×step each step. */
+        mode: 'add' | 'mul';
+        step: number;
+        cap: number | null;
+        /** Keep climbing across free-spins instead of resetting per spin. */
+        persistInFreeSpins: boolean;
+    };
+}
+interface WinConfig {
+    highlightScale: number;
+    glow: boolean;
+    /** Frame shake on landing/win. */
+    frameShake: {
+        enabled: boolean;
+        amp: number;
+        ms: number;
+        onlyOnSymbols: string[] | null;
+    };
+}
+interface ExpandingWildConfig {
+    enabled: boolean;
+    symbol: string;
+    /** Reels that may host an expanding wild (empty = all). */
+    reels: number[];
+    /** Expand to the full reel height. */
+    toFullReel: boolean;
+    ms: number;
+    easing: EasingName;
+    onlyInFreeSpins: boolean;
+}
+interface StickyConfig {
+    enabled: boolean;
+    symbols: string[];
+    /** How many spins a sticky symbol persists (0 = whole feature/bonus). */
+    durationSpins: number;
+    /** Ring colour drawn around sticky cells. */
+    ringColor: number;
+}
+interface WalkingWildConfig {
+    enabled: boolean;
+    symbol: string;
+    direction: 'left' | 'right';
+    stepPerSpin: number;
+    awardsRespin: boolean;
+    asStacked: boolean;
+}
+interface MultiplierConfig {
+    enabled: boolean;
+    /** Multiplier symbol id (carries a value), or null when multipliers are per-cell data. */
+    symbol: string | null;
+    scope: 'perSymbol' | 'perReel' | 'global';
+    combine: 'additive' | 'multiplicative';
+    attachedToWild: boolean;
+    max: number;
+    accumulateAcrossFreeSpins: boolean;
+}
+interface MysteryConfig {
+    enabled: boolean;
+    symbol: string;
+    /** Eligible reveal targets; all mystery tiles reveal the SAME single draw per spin. */
+    revealPool: string[];
+    canRevealWild: boolean;
+    ms: number;
+}
+interface TransformConfig {
+    enabled: boolean;
+    /** Trigger symbol whose landing fires the transform (null = data-driven). */
+    trigger: string | null;
+    /** 'randomLow' picks one low symbol at random; or pin a specific source. */
+    source: 'randomLow' | string;
+    target: string;
+    /** Convert every instance of the source symbol. */
+    allInstances: boolean;
+    /** Restrict to low→high (upgrade) direction. */
+    upgradeOnly: boolean;
+    ms: number;
+}
+interface GiantConfig {
+    enabled: boolean;
+    /** Footprint in cells. */
+    width: number;
+    height: number;
+    /** Symbols that may appear giant (empty = any). */
+    symbols: string[];
+    /** Pick one giant symbol type per spin. */
+    chosenPerSpin: boolean;
+    onlyInFreeSpins: boolean;
+}
+interface SplitConfig {
+    enabled: boolean;
+    symbol: string;
+    factor: number;
+    /** Reels that can host the split trigger (xSplit lands on the last reel). */
+    reels: number[];
+    /** Defer the split execution until all respins finish. */
+    deferUntilRespinsEnd: boolean;
+}
+interface StackedConfig {
+    enabled: boolean;
+    symbols: string[];
+    /** Max stack height (positions of the same symbol on one reel). */
+    height: number;
+}
+interface NudgeConfig {
+    enabled: boolean;
+    /** Reels eligible to nudge. */
+    reels: number[];
+    step: number;
+    /** xNudge: nudge a stacked wild into full view, +1 multiplier per nudge. */
+    toFullReel: boolean;
+    multiplierStart: number;
+    multiplierPerNudge: number;
+}
+interface ReelModifierConfig {
+    enabled: boolean;
+    /** Random pre-spin modifiers, each with a trigger weight. */
+    pool: {
+        effect: 'addRows' | 'addWilds' | 'setGiant' | 'guaranteedWilds';
+        magnitude: number;
+        weight: number;
+    }[];
+    appliesIn: 'base' | 'freeSpins' | 'both';
+}
+interface HoldAndSpinConfig {
+    enabled: boolean;
+    lockSymbols: string[];
+    triggerThreshold: number;
+    respinsAwarded: number;
+    /** Reset the respin counter to full whenever a new symbol locks. */
+    resetOnNewSymbol: boolean;
+    jackpotTiers: string[];
+    fullGridAwardsGrand: boolean;
+}
+interface RandomWildConfig {
+    enabled: boolean;
+    /** Fixed count, or [min,max] range. */
+    count: number | [number, number];
+    sticky: boolean;
+    multiplier: number;
+    trigger: 'randomBaseSpin' | 'onFreeSpins';
+    chance: number;
+}
+interface FeaturesConfig {
+    expandingWild: ExpandingWildConfig;
+    sticky: StickyConfig;
+    walkingWild: WalkingWildConfig;
+    multiplier: MultiplierConfig;
+    mystery: MysteryConfig;
+    transform: TransformConfig;
+    giant: GiantConfig;
+    split: SplitConfig;
+    stacked: StackedConfig;
+    nudge: NudgeConfig;
+    reelModifier: ReelModifierConfig;
+    holdAndSpin: HoldAndSpinConfig;
+    randomWild: RandomWildConfig;
+}
+/** Ordered list of feature keys (resolve order matters; see docs §3.4). */
+type FeatureKey = keyof FeaturesConfig;
+declare const FEATURE_KEYS: FeatureKey[];
+interface ReelSystemConfig {
+    grid: GridConfig;
+    motion: MotionConfig;
+    anticipation: AnticipationConfig;
+    cascade: CascadeConfig;
+    win: WinConfig;
+    features: FeaturesConfig;
+}
+/** Deep-partial helper for overrides. */
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends (infer U)[] ? T[K] : T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+declare const DEFAULT_REEL_CONFIG: ReelSystemConfig;
+/** Intensity → duration scale (accessibility). */
+declare const INTENSITY_SCALE: Record<Intensity, number>;
+/** Deep-merge `partial` onto `base` (arrays replace, objects merge). Returns a new object. */
+declare function mergeReelConfig<T>(base: T, partial?: DeepPartial<T>): T;
+/** Resolve a partial config to a fully-populated `ReelSystemConfig`. */
+declare function resolveReelConfig(partial?: DeepPartial<ReelSystemConfig>): ReelSystemConfig;
+/** Effective per-reel row counts (resolves Megaways `rowsPerReel`, else uniform `rows`). */
+declare function effectiveRowsPerReel(grid: GridConfig): number[];
+/** Total ways-to-win for a ways/megaways grid (product of per-reel heights). */
+declare function waysCount(grid: GridConfig): number;
+
+type PresetId = 'classic' | 'kitsune-wrath' | 'moon-spice' | 'stone-rush' | 'hot-ross' | 'magnus' | 'megaways';
+interface ReelPreset {
+    id: PresetId;
+    name: string;
+    note: string;
+    config: DeepPartial<ReelSystemConfig>;
+}
+declare const PRESETS: Record<PresetId, ReelPreset>;
+declare const PRESET_LIST: ReelPreset[];
+
+interface SpinData {
+    /** Target board: targetGrid[col][row]. */
+    targetGrid: CellData[][];
+    /** Optional per-reel symbol tape for the spinning illusion (defaults to random of the landing symbols). */
+    strip?: (reel: number) => string[];
+}
+interface SpinRunOpts {
+    turbo?: boolean;
+    /** Reels to slow for anticipation (computed by the ReelSystem from config + targetGrid). */
+    anticipateReels?: number[];
+    anticipateSlowdown?: number;
+    anticipateHoldMs?: number;
+}
+interface ReelStopPlan {
+    reel: number;
+    /** Wall-clock time (ms) from spin start when this reel stops. */
+    stopTime: number;
+    landing: CellData[];
+    settle: {
+        amp: number;
+        ms: number;
+    };
+    anticipated: boolean;
+}
+declare class SpinEngine {
+    private _grid;
+    private _resolve;
+    private _cfg;
+    private _win;
+    private _killed;
+    private _shaking;
+    private _temp;
+    constructor(grid: ReelGrid, resolve: SymbolResolver, cfg: MotionConfig, win?: WinConfig);
+    setConfig(cfg: MotionConfig): void;
+    setWin(win: WinConfig): void;
+    /** Quick decaying frame shake when a landed reel carries a configured trigger symbol. */
+    private _frameShake;
+    private scale;
+    /** PURE: per-reel stop schedule. No Pixi mutation. */
+    plan(data: SpinData, opts?: SpinRunOpts): ReelStopPlan[];
+    /** Execute the spin for every reel concurrently. */
+    run(data: SpinData, opts?: SpinRunOpts): Promise<void>;
+    private _runReel;
+    /** Anticipation time-stretch factor for a reel (>=1, longer = slower). */
+    private slowOf;
+    private _runSwap;
+    private _runStrip;
+    private _runDrop;
+    private _settle;
+    private _squashCell;
+    /** Apply motion blur (alpha + optional BlurFilter) to targets; returns a disposer that clears it. */
+    private _applyBlur;
+    private _cleanupTemp;
+    /** Slam / quick stop: snap everything to the target and stop animating. */
+    skip(): void;
+}
+
+interface AnticipationDecision {
+    active: boolean;
+    /** Reel indices that should spin slower / longer. */
+    reels: number[];
+    slowdown: number;
+    holdMs: number;
+}
+declare class AnticipationController {
+    private _cfg;
+    constructor(cfg: AnticipationConfig);
+    setConfig(cfg: AnticipationConfig): void;
+    /** Count how many trigger symbols land on a given reel. */
+    private countOnReel;
+    /**
+     * Decide anticipation from the landing grid. Trigger symbols are counted left→right;
+     * once the running total reaches `threshold`, every still-spinning reel after that point
+     * is flagged for the slow treatment (this mirrors "searching for the last scatter").
+     */
+    decide(targetGrid: CellData[][]): AnticipationDecision;
+    /** Optionally zoom the grid in while anticipating, then settle back. Returns a reset fn. */
+    zoomIn(grid: ReelGrid): Promise<() => Promise<void>>;
+}
+
+interface TumbleStep {
+    winningCells: {
+        col: number;
+        row: number;
+    }[];
+    removedCells: {
+        col: number;
+        row: number;
+    }[];
+    /** Optional explicit survivor slides (col, fromRow→toRow). When omitted, gravity is derived. */
+    drops?: {
+        col: number;
+        fromRow: number;
+        toRow: number;
+    }[];
+    newCells: {
+        col: number;
+        row: number;
+        symbol: string;
+    }[];
+    settledGrid: CellData[][];
+}
+declare class TumbleController {
+    private _grid;
+    private _cfg;
+    private _win;
+    private _killed;
+    private _mult;
+    constructor(grid: ReelGrid, cfg: CascadeConfig, win?: WinConfig);
+    setConfig(cfg: CascadeConfig): void;
+    setWin(win: WinConfig): void;
+    /** Killed, or the grid was torn down underneath us (rebuild during a cascade). */
+    private get _dead();
+    get multiplier(): number;
+    resetMultiplier(): void;
+    private advanceMultiplier;
+    /** Derive survivor slides for one column when explicit drops aren't supplied. */
+    private deriveDrops;
+    /** Run a single cascade step. `stepIndex` drives per-step deceleration. */
+    step(step: TumbleStep, stepIndex?: number, opts?: {
+        turbo?: boolean;
+    }): Promise<void>;
+    private _dim;
+    private _undim;
+    private _resetPositions;
+    skip(): void;
+}
+
+interface FeatureContext {
+    grid: ReelGrid;
+    resolve: SymbolResolver;
+    cfg: ReelSystemConfig;
+    /** Overlay layer above the grid for rings/labels/sprites. */
+    fx: Container;
+    /** Mutable view of the current board (featureN may rewrite it). */
+    board: CellData[][];
+    /** Whether the current spin is a free-spin (gates onlyInFreeSpins features). */
+    freeSpins?: boolean;
+    /** Emit a human-readable note for the playground log. */
+    log?: (msg: string) => void;
+}
+interface ReelFeature {
+    /** Unique id. Built-ins use a `FeatureKey`; custom features may use any string. */
+    readonly key: FeatureKey | string;
+    readonly label: string;
+    /** Whether this feature is active for the given config. Custom features can just return `true`. */
+    enabled(cfg: ReelSystemConfig): boolean;
+    /** Run the feature presentation on the current board. */
+    demo(ctx: FeatureContext): Promise<void>;
+}
+
+/** All feature modules keyed by their FeatureKey. */
+declare const FEATURES: Record<FeatureKey, ReelFeature>;
+/** Features in canonical resolve order (see docs §3.4). */
+declare const FEATURE_LIST: ReelFeature[];
+
+interface CreateReelSystemOptions {
+    resolve: SymbolResolver;
+    config?: DeepPartial<ReelSystemConfig>;
+    /** Initial board (board[col][row]); defaults to empty cells. */
+    board?: CellData[][];
+    log?: (msg: string) => void;
+    /** Custom feature modules to register alongside the 13 built-ins. */
+    features?: ReelFeature[];
+}
+interface ReelSystem {
+    /** Root container — add this to your scene. */
+    readonly view: Container;
+    readonly grid: ReelGrid;
+    /** Overlay layer above the grid (masked off) — draw bespoke rings/labels/sprites here. */
+    readonly fx: Container;
+    readonly config: ReelSystemConfig;
+    /** Current board (board[col][row]). */
+    readonly board: CellData[][];
+    /** Ways-to-win for the current grid (ways/megaways evaluation). */
+    readonly ways: number;
+    setBoard(board: CellData[][]): void;
+    /** Merge a partial config; rebuilds the grid when geometry changes. */
+    update(partial: DeepPartial<ReelSystemConfig>): void;
+    /** Replace the whole config. */
+    setConfig(config: ReelSystemConfig): void;
+    spin(target: CellData[][], opts?: SpinRunOpts): Promise<void>;
+    /** Run a cascade chain. With `freeSpins` + `cascade.multiplier.persistInFreeSpins`, the multiplier carries over instead of resetting. */
+    cascade(steps: TumbleStep[], opts?: {
+        turbo?: boolean;
+        freeSpins?: boolean;
+    }): Promise<void>;
+    /** Current running cascade multiplier. */
+    readonly multiplier: number;
+    /** Register a custom feature (or override a built-in by reusing its key). */
+    registerFeature(feature: ReelFeature): void;
+    /** All registered features (built-ins + custom) in canonical order. */
+    features(): ReelFeature[];
+    /** Enabled feature modules (built-ins + custom). */
+    enabledFeatures(): ReelFeature[];
+    /** Run a feature by key — built-in `FeatureKey` or a custom feature's key. */
+    runFeature(key: FeatureKey | string, opts?: {
+        freeSpins?: boolean;
+    }): Promise<void>;
+    /** Build a FeatureContext for driving a feature/bespoke animation yourself. */
+    featureContext(opts?: {
+        freeSpins?: boolean;
+    }): FeatureContext;
+    resize(cellSize: number): void;
+    skip(): void;
+    destroy(): void;
+}
+declare function createReelSystem(opts: CreateReelSystemOptions): ReelSystem;
+
 interface WinTier {
     id: string;
     minMultiplier: number;
@@ -329,5 +879,5 @@ declare class MultiplierAccumulator {
     reset(boundary: CarryPolicy): void;
 }
 
-export { AnimatedSymbol, BigWinOverlay, CascadeController, CountUpDisplay, FreeSpinsSession, MultiplierAccumulator, ReelGrid, ReelSpinController, SymbolCell, pickTier, tierIndexAtValue, valueAt };
-export type { AnimatedSymbolConfig, BigWinOverlayConfig, CarryPolicy, CascadeAnim, CascadeStepData, CascadeTimings, CellData, CellFrameStyle, CellState, CountUpConfig, DecorationConfig, FreeSpinsSessionConfig, ReelGridConfig, ReelSpinData, ReelSpinTimings, ReelStopPlan, SymbolCellConfig, SymbolResolver, SymbolTextures, SymbolView, WinTier };
+export { AnimatedSymbol, AnticipationController, BigWinOverlay, CascadeController, CountUpDisplay, DEFAULT_REEL_CONFIG, EASING_BY_NAME, FEATURES, FEATURE_KEYS, FEATURE_LIST, FreeSpinsSession, INTENSITY_SCALE, MultiplierAccumulator, PRESETS, PRESET_LIST, ReelGrid, ReelSpinController, SpinEngine, SymbolCell, TumbleController, createReelSystem, easingByName, effectiveRowsPerReel, mergeReelConfig, pickTier, resolveReelConfig, tierIndexAtValue, valueAt, waysCount };
+export type { AnimatedSymbolConfig, AnticipationConfig, AnticipationDecision, BigWinOverlayConfig, BlurConfig, CarryPolicy, CascadeAnim, CascadeConfig, CascadeStepData, CascadeTimings, CellData, CellFrameStyle, CellState, CountUpConfig, CreateReelSystemOptions, DecorationConfig, DeepPartial, EasingName, EvaluationMode, ExpandingWildConfig, FeatureContext, FeatureKey, FeaturesConfig, FreeSpinsSessionConfig, GiantConfig, GridConfig, HoldAndSpinConfig, Intensity, MotionConfig, MotionStyle, MultiplierConfig, MysteryConfig, NudgeConfig, PresetId, RandomWildConfig, ReelFeature, ReelGridConfig, ReelModifierConfig, ReelPreset, ReelSpinData, ReelSpinTimings, ReelStopPlan$1 as ReelStopPlan, ReelSystem, ReelSystemConfig, SettleConfig, SpinData, SpinRunOpts, ReelStopPlan as SpinStopPlan, SplitConfig, SquashConfig, StackedConfig, StickyConfig, StopMode, StopOrder, SymbolCellConfig, SymbolResolver, SymbolTextures, SymbolView, TransformConfig, TumbleStep, WalkingWildConfig, WinConfig, WinTier };