@betorigami/games 2.10.1 → 2.10.2

package/dist/components/mines/MinesTile/MinesTile.d.ts

@@ -0,0 +1,49 @@
+import { PropertyValues } from 'lit';
+import { HapticsController } from '../../../controllers/haptics.controller';
+import { SoundEffectsController } from '../../../controllers/sound/sound-effects.controller';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare enum MinesTileState {
+    NORMAL = "NORMAL",
+    AUTOBET_SELECTED = "AUTOBET_SELECTED",
+    SELECTED_GEM = "SELECTED_GEM",
+    UNSELECTED_GEM = "UNSELECTED_GEM",
+    SELECTED_BOMB = "SELECTED_BOMB",
+    UNSELECTED_BOMB = "UNSELECTED_BOMB",
+    AUTOBET_SELECTED_GEM = "AUTOBET_SELECTED_GEM",
+    AUTOBET_SELECTED_BOMB = "AUTOBET_SELECTED_BOMB"
+}
+export declare class MinesTile extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    tileId: number;
+    delayReveal: boolean;
+    isAutoMode: boolean;
+    state: MinesTileState;
+    ariaLabel: string;
+    isLoading: boolean;
+    disabled: boolean;
+    language: import('../../..').Language;
+    soundEffects?: SoundEffectsController;
+    haptics?: HapticsController;
+    tileSvgUrl: string | null;
+    autobetSelectedTileSvgUrl: string | null;
+    gemSvgUrl: string | null;
+    bombSvgUrl: string | null;
+    private bombGifVersion;
+    private bombGifActive;
+    private bombGifTimeout;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    private get _isRevealed();
+    private get _isMine();
+    private get _isGem();
+    private get _isDisabled();
+    private get _isSelected();
+    private get _shouldShowBombFg();
+    private get _shouldShowBombBg();
+    private _isSelectedBombState;
+    private get _currentTileSvgUrl();
+    private _activateBombGif;
+    disconnectedCallback(): void;
+    private _handlePointerDown;
+    private _handleClick;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/mines/MinesTile/MinesTile.styles.d.ts

@@ -0,0 +1 @@
+export declare const minesTileStyles: import('lit').CSSResult;

package/dist/components/mines/mines.api.d.ts

@@ -0,0 +1,66 @@
+import { default as Big } from 'big.js';
+import { Action, BaseStartArgs } from '../../shared/bet.types';
+import { ErrorBetResult, SettledBetFields } from '../../shared/provider-api/bet-result';
+import { MinesState } from './mines.constants';
+export type MinesManualStartArgs = {
+    amount: string;
+    minesCount: number;
+};
+export type MinesNextArgs = {
+    betId?: string;
+    selectedTiles: number[];
+};
+export interface MinesAutoArgs extends BaseStartArgs {
+    minesCount: number;
+    selectedTiles: number[];
+}
+type MinesApiBetBase = {
+    readonly id: string;
+    readonly amount: Big;
+    readonly state: MinesState;
+};
+export type MinesActiveBet = MinesApiBetBase & {
+    readonly settled: false;
+};
+export type MinesStartedBet = MinesApiBetBase & {
+    readonly settled: false;
+    readonly afterBalance: Big;
+};
+export type MinesSettledBet = MinesApiBetBase & SettledBetFields & {
+    readonly settled: true;
+};
+export type MinesApiBet = MinesActiveBet | MinesStartedBet | MinesSettledBet;
+export type MinesStartResult = ({
+    readonly success: true;
+} & MinesStartedBet) | ErrorBetResult;
+export type MinesSelectTileResult = ({
+    readonly success: true;
+} & (MinesActiveBet | MinesSettledBet)) | ErrorBetResult;
+export type MinesSettledResult = ({
+    readonly success: true;
+} & MinesSettledBet) | ErrorBetResult;
+export type MinesActiveBetResult = {
+    readonly success: true;
+    readonly data: MinesActiveBet | null;
+} | ErrorBetResult;
+export interface IMinesApi {
+    getActiveBet(): Promise<MinesActiveBetResult>;
+    startManualBet(data: MinesManualStartArgs): Promise<MinesStartResult>;
+    selectTile(data: MinesNextArgs): Promise<MinesSelectTileResult>;
+    cashout(): Promise<MinesSettledResult>;
+    autobetPlay(data: MinesAutoArgs): Promise<MinesSettledResult>;
+}
+export declare class MinesApi implements IMinesApi {
+    private readonly authToken;
+    private readonly baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startManualBet(data: MinesManualStartArgs): Promise<MinesStartResult>;
+    getActiveBet(): Promise<MinesActiveBetResult>;
+    selectTile(data: MinesNextArgs): Promise<MinesSelectTileResult>;
+    cashout(): Promise<MinesSettledResult>;
+    autobetPlay(data: MinesAutoArgs): Promise<MinesSettledResult>;
+    static deriveSelectedTiles(betActions: Action[]): number[];
+    static deriveMineLocations(betActions: Action[]): number[];
+    static calculateMinesMultiplier(gemsFound: number, mines: number, edge: number): Big;
+}
+export {};

package/dist/components/mines/mines.constants.d.ts

@@ -0,0 +1,27 @@
+import { default as Big } from 'big.js';
+export declare enum MinesGameOutcome {
+    WIN = "WIN",
+    LOSS = "LOSS"
+}
+export declare enum MinesFlowState {
+    GAME_IN_PROGRESS = "GAME_IN_PROGRESS",
+    VIEWING_RESULTS = "VIEWING_RESULTS"
+}
+export interface MinesState {
+    selectedTiles: number[];
+    mineLocations: number[];
+    outcome: MinesGameOutcome | null;
+    minesCount: number;
+    numMinesRemaining: number;
+    numGemsFound: number;
+    numGemsRemaining: number;
+    state: MinesFlowState;
+    betAmount: Big;
+}
+export declare const MINES_TILES_COUNT = 25;
+export declare const MINES_MAX_MINES = 24;
+export declare const MINES_DEFAULT_COUNT = 3;
+export declare const minesCountOptions: {
+    value: string;
+    label: string;
+}[];

package/dist/components/mines/mines.mock.api.d.ts

@@ -0,0 +1,22 @@
+import { IMinesApi, MinesActiveBetResult, MinesAutoArgs, MinesManualStartArgs, MinesNextArgs, MinesSelectTileResult, MinesSettledResult, MinesStartResult } from './mines.api';
+export declare class MockMinesApi implements IMinesApi {
+    private readonly getEdge;
+    private readonly getBalance;
+    private activeBet;
+    private minePositions;
+    constructor(getEdge: () => number, getBalance: () => number);
+    startManualBet(data: MinesManualStartArgs): Promise<MinesStartResult>;
+    getActiveBet(): Promise<MinesActiveBetResult>;
+    selectTile(data: MinesNextArgs): Promise<MinesSelectTileResult>;
+    cashout(): Promise<MinesSettledResult>;
+    autobetPlay(data: MinesAutoArgs): Promise<MinesSettledResult>;
+    private isValidBetAmount;
+    private clearActiveBet;
+    private static createState;
+    private getNextSelectedTiles;
+    private getSettlement;
+    private static error;
+    private static generateMinePositions;
+    private static isValidMinesCount;
+    private static isValidTile;
+}

package/dist/components/plinko/PlinkoContent/PlinkoBin/PlinkoBin.d.ts

@@ -0,0 +1,13 @@
+import { default as OrigamiElement } from '../../../../shared/origami-element';
+export declare class PlinkoBin extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    multiplier: number;
+    bounceCount: number;
+    backgroundColor: string;
+    shadowColor: string;
+    private binEl;
+    private animation?;
+    updated(changedProperties: Map<PropertyKey, unknown>): void;
+    private startBounceAnimation;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/plinko/PlinkoContent/PlinkoBin/PlinkoBin.styles.d.ts

@@ -0,0 +1 @@
+export declare const plinkoBinStyles: import('lit').CSSResult;

package/dist/components/plinko/PlinkoContent/PlinkoBins/PlinkoBins.d.ts

@@ -0,0 +1,10 @@
+import { nothing } from 'lit';
+import { default as OrigamiElement } from '../../../../shared/origami-element';
+import { BinsLayout } from '../../plinko-content.utils';
+export declare class PlinkoBins extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    binsLayout?: BinsLayout;
+    bounceCounts: Map<number, number>;
+    binRadius: number;
+    render(): typeof nothing | import('lit').TemplateResult<1>;
+}

package/dist/components/plinko/PlinkoContent/PlinkoBins/PlinkoBins.styles.d.ts

@@ -0,0 +1 @@
+export declare const plinkoBinsStyles: import('lit').CSSResult;

package/dist/components/plinko/PlinkoContent/PlinkoContent.d.ts

@@ -0,0 +1,67 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { SupportedEdgePercentages } from '../../../shared/constants';
+import { PlinkoRiskLevel, PlinkoRowCount } from '../plinko.constants';
+export declare class PlinkoContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    isDesktop: boolean;
+    isPlaying: boolean;
+    history: Array<{
+        multiplier: number;
+        won: boolean;
+        id: string;
+        color?: string;
+    }>;
+    rowCount: PlinkoRowCount;
+    riskLevel: PlinkoRiskLevel;
+    edge: SupportedEdgePercentages;
+    customPlinkoEdgeColor: string | null;
+    customPlinkoCenterColor: string | null;
+    private ballsInFlight;
+    private containerWidth;
+    private canvasWrapRef;
+    private svgRef;
+    private ballsSvgRef;
+    private effectsSvgRef;
+    private engine?;
+    private resizeObserver?;
+    private bounceCounts;
+    private spawnMap;
+    private reduceMotion;
+    private activeBets;
+    private pulses;
+    private pulsePool;
+    private engineAnimationId?;
+    private pulseAnimationId?;
+    firstUpdated(): void;
+    updateRowCount(): void;
+    updateBallsInFlight(): void;
+    disconnectedCallback(): void;
+    /**
+     * Adds a new pulse effect at the given position
+     */
+    private addPulse;
+    /**
+     * Starts the pulse animation loop
+     */
+    private startPulseAnimation;
+    private setupResizeObserver;
+    private startUpdateEngineLoop;
+    /**
+     * Renders all active pulses and removes expired ones
+     */
+    private renderPulses;
+    /**
+     * Drops a ball from a predetermined position to hit a specific bin.
+     * @param binIndex Which bin this ball should land in
+     * @param betId Unique identifier for this bet (required)
+     */
+    dropBallForResult(binIndex: number, betId: string): void;
+    /**
+     * Triggers an instant result without ball animation (for reduced motion or fast mode)
+     * @param multiplier The multiplier result
+     * @param betId Unique identifier for this bet (required)
+     */
+    triggerInstantResult(edge: SupportedEdgePercentages, multiplier: number, betId: string): void;
+    private triggerBinBounce;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/plinko/PlinkoContent/PlinkoContent.styles.d.ts

@@ -0,0 +1 @@
+export declare const plinkoContentStyles: import('lit').CSSResult;

package/dist/components/plinko/PlinkoControls/PlinkoAuto.d.ts

@@ -0,0 +1,14 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { PlinkoRiskLevel, PlinkoRowCount } from '../plinko.constants';
+export declare class PlinkoAuto extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    betDisabled: boolean;
+    isDesktop: boolean;
+    rowCount: PlinkoRowCount;
+    riskLevel: PlinkoRiskLevel;
+    betMaxMultiplier: number;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/plinko/PlinkoControls/PlinkoControls.styles.d.ts

@@ -0,0 +1 @@
+export declare const plinkoControlsStyles: import('lit').CSSResult;

package/dist/components/plinko/PlinkoControls/PlinkoManual.d.ts

@@ -0,0 +1,16 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { PlinkoRiskLevel, PlinkoRowCount } from '../plinko.constants';
+export declare class PlinkoManual extends OrigamiElement {
+    isPlaying: boolean;
+    betDisabled: boolean;
+    inputsDisabled: boolean;
+    rowCount: PlinkoRowCount;
+    riskLevel: PlinkoRiskLevel;
+    betMaxMultiplier: number;
+    gameData: gameContextType;
+    private isBetAmountValid;
+    private _betAboveBalance;
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/plinko/PlinkoEngine.d.ts

@@ -0,0 +1,164 @@
+import { PlinkoRowCount } from './plinko.constants';
+/**
+ * Raw physics event callbacks - no game logic, just physics data
+ * The UI layer handles game logic (multipliers, visual effects)
+ */
+export type PlinkoEngineEvents = {
+    onBallPositions?: (balls: Array<{
+        betId: string;
+        x: number;
+        y: number;
+        r: number;
+    }>) => void;
+    onBallHitPin?: (args: {
+        betId: string;
+        pinX: number;
+        pinY: number;
+        impactSpeed: number;
+    }) => void;
+    onBallCrossedSensor?: (args: {
+        betId: string;
+    }) => void;
+};
+/**
+ * PlinkoEngine: Core physics simulation for the Plinko game
+ * Uses Matter.js to simulate realistic ball physics as it bounces through pins
+ */
+export default class PlinkoEngine {
+    private static readonly SENSOR_HEIGHT;
+    private static readonly GRAVITY_Y;
+    private static readonly START_GAP;
+    private static readonly END_GAP;
+    private static readonly BIN_DESPAWN_OFFSET;
+    static readonly WIDTH = 1336;
+    static readonly HEIGHT = 1002;
+    /**
+     * Ball physics properties (tuned to match Shuffle's implementation):
+     * - friction: Resistance when ball slides against pins (0.5 = moderate)
+     * - restitution: Bounciness (0.7 = 70% of velocity retained after bounce)
+     * - density: Mass per unit area (0.5 = relatively light)
+     * - frictionAir: Air resistance (defaults to 0.01 in Matter.js)
+     */
+    private static BALL_CONFIG;
+    private static readonly PIN_CATEGORY;
+    private static readonly BALL_CATEGORY;
+    private rowCount;
+    private engine;
+    private pins;
+    private pinsSet;
+    private sensor;
+    private events;
+    private balls;
+    private ballToBetId;
+    private ballPositionsCache;
+    /**
+     * Initializes the physics engine and sets up collision detection
+     * @param config Game configuration (rowCount)
+     * @param events Optional event callbacks for UI integration
+     */
+    constructor(rowCount: PlinkoRowCount, events?: PlinkoEngineEvents);
+    /**
+     * Checks if a body is a pin (O(1) lookup using Set)
+     */
+    private isPin;
+    /**
+     * Checks if a body is a ball based on collision category
+     */
+    private isBall;
+    /**
+     * Handles all collision events in the physics world
+     * - Detects balls entering bins (ball-sensor collision)
+     * - Emits ball-pin collision events for visual effects
+     */
+    private handleCollisionStart;
+    /**
+     * Emits ball-pin collision data for visual effects (pulses)
+     * Calculates impact speed and passes raw data to callback
+     */
+    private emitBallHitPin;
+    /**
+     * Called after each physics update to send ball positions to UI
+     */
+    private handleAfterUpdate;
+    update(): void;
+    /**
+     * Changes the number of rows of pins
+     * Rebuilds the entire pin layout and clears all active balls
+     */
+    setRowCount(rowCount: PlinkoRowCount): void;
+    /**
+     * Drops a ball from a predetermined position to hit a specific bin.
+     * This is the ONLY way to drop a ball - the server determines the outcome.
+     *
+     * @param binIndex Which bin this ball should land in (0 to rowCount)
+     * @param betId Unique identifier for this bet (required for tracking)
+     * @throws Error if no starting positions exist for the given binIndex
+     */
+    dropBallForResult(binIndex: number, betId: string): void;
+    /**
+     * Creates a ball body at the specified X position
+     */
+    private createBall;
+    /**
+     * Deterministically converts a string to an index within a range.
+     * Uses simple hash to ensure same betId always produces same starting position.
+     */
+    private hashStringToIndex;
+    /**
+     * Returns what percentage of screen width the bins occupy
+     * Used by UI to calculate bin widths
+     */
+    get binsWidthPercentage(): number;
+    get activeBallCount(): number;
+    get ballRadius(): number;
+    /**
+     * Calculates pin size, spacing, and ball size based on row count
+     * More rows = smaller pins/balls to fit in same vertical space
+     *
+     * @param rowCount Number of rows (8-16)
+     * @returns Object with pegRadius, spacing, and ballRadius
+     */
+    static getPinConfig(rowCount: PlinkoRowCount): {
+        pegRadius: number;
+        spacing: number;
+        ballRadius: number;
+    };
+    /**
+     * Gets pin configuration for current instance's row count
+     */
+    private getPinConfig;
+    /**
+     * Called when ball crosses the sensor at bottom of screen
+     * Emits event that ball has landed
+     *
+     * @param ball The ball body that crossed the sensor
+     */
+    private handleBallCrossedSensor;
+    /**
+     * Creates all pins based on current row count
+     * Called during initialization and when row count changes
+     *
+     * Pin layout:
+     * Row 0: 3 pins
+     * Row 1: 4 pins
+     * Row 2: 5 pins
+     * etc.
+     * Row N: (3 + N) pins
+     */
+    private placePins;
+    /**
+     * Positions the sensor bar at the bottom of the play area
+     * Sensor detects when balls enter bins
+     */
+    private updateSensorPosition;
+    /**
+     * Removes all balls from the physics world
+     * Called when changing row count or cleaning up
+     */
+    private removeAllBalls;
+    /**
+     * Destroys the engine and cleans up all resources
+     * Should be called when the game component is removed from DOM
+     */
+    destroy(): void;
+}

package/dist/components/plinko/PlinkoGame.d.ts

@@ -0,0 +1,47 @@
+import { AutobetSettingsWithId, GameBetResult, GameComponent } from '../shared/GameComponent';
+import { PlinkoApi } from './plinko.api';
+import { MockPlinkoApi } from './plinko.mock.api';
+export interface PlinkoHistory {
+    multiplier: number;
+    won: boolean;
+    id: string;
+    payout: string;
+    color?: string;
+}
+export declare class PlinkoGame extends GameComponent {
+    static styles: import('lit').CSSResult[];
+    private history;
+    private riskLevel;
+    private rowCount;
+    private ballsInFlight;
+    private lastSubBassTime;
+    private pendingResultsByBetId;
+    private betQueue;
+    private _plinkoManualEl?;
+    private _plinkoAutoEl?;
+    private _plinkoContentEl?;
+    get isGameInProgress(): boolean;
+    get plinkoApi(): PlinkoApi | MockPlinkoApi;
+    constructor();
+    private get customBinColors();
+    get binMultipliers(): number[];
+    private handleBetExecution;
+    /**
+     * Queued wrapper for handleBetExecution that throttles requests.
+     * Uses a bounded queue with concurrency limiting to prevent overwhelming the backend.
+     * - Requests beyond queue capacity are silently dropped (no error shown to user)
+     * - Up to maxConcurrent requests run simultaneously
+     */
+    private queuedBetExecution;
+    plinkoPlay(): Promise<void>;
+    protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
+    /**
+     * Resolves multiplier and win status from a bin hit event.
+     * Uses server result from pendingResultsByBetId via betId.
+     */
+    private resolveMultiplierAndWin;
+    private _getPitchFromMultiplier;
+    private playResultSound;
+    private handleBinHit;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/plinko/PlinkoGame.styles.d.ts

@@ -0,0 +1 @@
+export declare const plinkoGameStyles: import('lit').CSSResult;

package/dist/components/plinko/PlinkoRowsSelect/PlinkoRiskSelect.d.ts

@@ -0,0 +1,10 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { PlinkoRiskLevel } from '../plinko.constants';
+export declare class PlinkoRiskSelect extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    value: PlinkoRiskLevel;
+    disabled: boolean;
+    gameData?: gameContextType;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/plinko/PlinkoRowsSelect/PlinkoRiskSelect.styles.d.ts

@@ -0,0 +1 @@
+export declare const plinkoRiskSelectStyles: import('lit').CSSResult;

package/dist/components/plinko/PlinkoRowsSelect/PlinkoRowsSelect.d.ts

@@ -0,0 +1,10 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { PlinkoRowCount } from '../plinko.constants';
+export declare class PlinkoRowsSelect extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    value: PlinkoRowCount;
+    disabled: boolean;
+    gameData?: gameContextType;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/plinko/PlinkoRowsSlider/PlinkoRowsSlider.d.ts

@@ -0,0 +1,12 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { PlinkoRowCount } from '../plinko.constants';
+export declare class PlinkoRowsSlider extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    value: PlinkoRowCount;
+    disabled: boolean;
+    private _displayValue;
+    gameData?: gameContextType;
+    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/plinko/PlinkoRowsSlider/PlinkoRowsSlider.styles.d.ts

@@ -0,0 +1 @@
+export declare const plinkoRowsSliderStyles: import('lit').CSSResult;

package/dist/components/plinko/plinko-content.utils.d.ts

@@ -0,0 +1,77 @@
+import { SupportedEdgePercentages } from '../../shared/constants';
+import { PlinkoRiskLevel, PlinkoRowCount } from './plinko.constants';
+export interface DisplayParams {
+    pegRadius: number;
+    spacing: number;
+    /** ViewBox origin X (left edge of peg bounding box) */
+    viewBoxX: number;
+    /** ViewBox origin Y (top edge of peg bounding box) */
+    viewBoxY: number;
+    /** ViewBox width (tight fit around pegs) */
+    viewBoxWidth: number;
+    /** ViewBox height (tight fit around pegs) */
+    viewBoxHeight: number;
+}
+/**
+ * Calculates display parameters for the Plinko canvas based on row count.
+ * ViewBox is calculated to tightly fit around the peg grid.
+ */
+export declare const getDisplayParams: (rowCount: PlinkoRowCount) => DisplayParams;
+export interface Ball {
+    betId: string;
+    x: number;
+    y: number;
+    r: number;
+}
+/** Rendered pulse data for SVG */
+export interface Pulse {
+    x: number;
+    y: number;
+    r: number;
+    alpha: number;
+}
+/** Internal pulse state for animation tracking */
+export interface PulseState {
+    x: number;
+    y: number;
+    startMs: number;
+    impact: number;
+}
+export declare const PULSE_CONSTANTS: {
+    readonly LIFE_MS: 260;
+    readonly BASE_RADIUS_MULT: 1.1;
+    readonly GROWTH_RADIUS_MULT: 1.6;
+};
+/**
+ * Converts internal pulse state to render data
+ * Returns null if pulse has expired
+ */
+export declare const computePulseRenderData: (pulse: PulseState, now: number, pegRadius: number) => Pulse | null;
+/**
+ * Calculates impact intensity from collision speed (0.25 to 1.0 range)
+ */
+export declare const calculateImpact: (impactSpeed: number) => number;
+export interface BinsLayout {
+    payouts: number[];
+    colors: {
+        background: string[];
+        shadow: string[];
+    };
+    paddingPx: number;
+    gapPx: number;
+    adjustedBinsWidthPct: number;
+}
+export declare const formatPlinkoMultiplier: (value: number) => string;
+export declare const renderPegsSvg: (svg: SVGSVGElement, displayParams: DisplayParams, rowCount: number) => void;
+export declare const renderBallsSvg: (svg: SVGSVGElement, balls: Ball[], displayParams: DisplayParams, state: {
+    spawnMap: Map<string, number>;
+    reduceMotion: boolean;
+}) => void;
+export declare const renderPulsesSvg: (svg: SVGSVGElement, pulses: Pulse[], displayParams: DisplayParams) => void;
+export declare const calculateBinsLayout: (edge: SupportedEdgePercentages, rowCount: PlinkoRowCount, riskLevel: PlinkoRiskLevel, params: {
+    pegRadius: number;
+    canvasCssWidth: number;
+    isDesktop: boolean;
+    customPlinkoEdgeColor: string | null;
+    customPlinkoCenterColor: string | null;
+}) => BinsLayout;

package/dist/components/plinko/plinko.api.d.ts

@@ -0,0 +1,14 @@
+import { BaseStartArgs, StartBetResponse } from '../../shared/bet.types';
+import { Language } from '../../translations';
+import { PlinkoRiskLevel, PlinkoRowCount } from './plinko.constants';
+export interface PlinkoStartArgs extends BaseStartArgs {
+    language: Language;
+    riskLevel: PlinkoRiskLevel;
+    rowCount: PlinkoRowCount;
+}
+export declare class PlinkoApi {
+    private authToken;
+    private baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: PlinkoStartArgs): Promise<StartBetResponse>;
+}