@betorigami/games 2.10.1 → 2.10.2

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

@@ -0,0 +1,47 @@
+import { SupportedEdgePercentages } from '../../shared/constants';
+export declare enum PlinkoRiskLevel {
+    LOW_RISK = "LOW_RISK",
+    MEDIUM_RISK = "MEDIUM_RISK",
+    HIGH_RISK = "HIGH_RISK"
+}
+export declare const plinkoRowCountOptions: readonly [8, 9, 10, 11, 12, 13, 14, 15, 16];
+export type PlinkoRowCount = (typeof plinkoRowCountOptions)[number];
+export declare const PLINKO_BIN_ANIMATION_DURATION = 250;
+/**
+ * Configuration for responsive bin sizing based on canvas width.
+ * These values were determined through visual design testing across different screen sizes.
+ */
+export declare const PLINKO_BIN_CONFIG: {
+    readonly WIDTH_TO_HEIGHT_RATIO: 23;
+    readonly HEIGHT: {
+        readonly MIN: 16;
+        readonly MAX: 28;
+    };
+    readonly RADIUS_RATIO: 0.18;
+    readonly RADIUS: {
+        readonly MIN: 3;
+        readonly MAX: 5;
+    };
+    readonly FONT_SIZE: {
+        readonly MIN: 5;
+        readonly MAX: 12;
+        readonly BIN_WIDTH_RATIO: 0.28;
+    };
+};
+type PlinkoMultiplierSet = Record<PlinkoRowCount, number[]>;
+type PlinkoMultipliers = Record<PlinkoRiskLevel, PlinkoMultiplierSet>;
+export declare const plinkoMultipliers: Record<SupportedEdgePercentages, PlinkoMultipliers>;
+export type RgbColor = {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare const ballColorsByRisk: Record<PlinkoRiskLevel, string>;
+export type BinColors = Record<PlinkoRowCount, {
+    background: string[];
+    shadow: string[];
+}>;
+export declare const getBinColors: (riskLevel: PlinkoRiskLevel, customEdgeColor: string | null, customCenterColor: string | null) => BinColors;
+export declare const getBinMultipliers: (edge: SupportedEdgePercentages, riskLevel: PlinkoRiskLevel, rowCount: PlinkoRowCount) => number[];
+export declare const PLINKO_BALL_STARTING_POINTS: number[][][];
+export {};

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

@@ -0,0 +1,11 @@
+import { BetResult } from '../../shared/bet.types';
+import { PlinkoStartArgs } from './plinko.api';
+import { SupportedEdgePercentages } from '../../shared/constants';
+export declare class MockPlinkoApi {
+    private readonly edge;
+    constructor(edge: SupportedEdgePercentages);
+    startBet(data: PlinkoStartArgs): Promise<{
+        success: true;
+        data: BetResult;
+    }>;
+}

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

@@ -0,0 +1,20 @@
+import { SupportedEdgePercentages } from '../../shared/constants';
+import { PlinkoRiskLevel, PlinkoRowCount } from './plinko.constants';
+/**
+ * Gets the bin index for a given multiplier value.
+ * Tries to find an exact match first, then falls back to a random valid bin.
+ */
+export declare const getBinIndexForMultiplier: (edge: SupportedEdgePercentages, multiplier: number, rowCount: PlinkoRowCount, riskLevel: PlinkoRiskLevel) => number;
+/**
+ * Calculates responsive bin sizing (height, border radius, font size) based on canvas width and bin count.
+ * Font scales based on actual bin width for robust responsiveness across all screen sizes and row counts.
+ *
+ * @param canvasWrapWidth - The current width of the canvas wrapper in pixels
+ * @param rowCount - Number of rows (bins = rowCount + 1)
+ * @returns Object containing height, radius, and fontSize values in pixels
+ */
+export declare const calculateBinSizing: (canvasWrapWidth: number, rowCount: number) => {
+    height: number;
+    radius: number;
+    fontSize: number;
+};

package/dist/components/roulette/RouletteAnimator/RouletteAnimator.d.ts

@@ -0,0 +1,42 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { RouletteType } from '../roulette.constants';
+export declare class RouletteAnimator extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    isPlaying: boolean;
+    hitNumber: number | null;
+    rouletteType: RouletteType;
+    staticDisplay: boolean;
+    instantBetEnabled: boolean;
+    isPrimary: boolean;
+    gameData?: gameContextType;
+    private _ballAngle;
+    private _ballDistanceFromCenter;
+    private _animationPhase;
+    private _rafId;
+    private _positionsArr;
+    private _positionIndex;
+    private _targetAngleOffset;
+    private _lastFrameTime;
+    private _hasEmittedLandEvent;
+    private _hasSetToFalling;
+    private _totalAngleTraveled;
+    private _ballContainer?;
+    private _ball?;
+    private get _isVisible();
+    disconnectedCallback(): void;
+    handleIsPlayingChange(): void;
+    handleHitNumberChange(prev?: unknown, next?: unknown): void;
+    handleStaticDisplayChange(): void;
+    handleInstantBetEnabledChange(): void;
+    private _setStaticBallPosition;
+    private _startAnimation;
+    private _resetState;
+    private _startLoop;
+    private _stopLoop;
+    private _handleCirclingPhase;
+    private _handleFallingPhase;
+    private _updateBallTransform;
+    private get _shouldShowBall();
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/roulette/RouletteAnimator/RouletteAnimator.styles.d.ts

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

package/dist/components/roulette/RouletteContent/RouletteContent.d.ts

@@ -0,0 +1,34 @@
+import { PropertyValues } from 'lit';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { RouletteType, RouletteHistoryEntry } from '../roulette.constants';
+import { default as Big } from 'big.js';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class RouletteContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    isDesktop: boolean;
+    isPlaying: boolean;
+    history: RouletteHistoryEntry[];
+    hitNumber: number | null;
+    displayedHitNumber: number | null;
+    lastResultNumber: number | null;
+    showOverlay: boolean;
+    placedChips: Map<string, number>;
+    canUndo: boolean;
+    canClear: boolean;
+    rouletteType: RouletteType;
+    instantBetEnabled: boolean;
+    showWinPopup: boolean;
+    payout: Big | null;
+    multiplier: number;
+    betId?: string;
+    get pastResults(): RouletteHistoryEntry[];
+    gameData?: gameContextType;
+    private _resizeObserver?;
+    protected firstUpdated(): void;
+    protected updated(changedProps: PropertyValues): void;
+    disconnectedCallback(): void;
+    private _handleWindowResize;
+    private _setupMobileWheelTracking;
+    private _updateMobileWheelShift;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/roulette/RouletteContent/RouletteContent.styles.d.ts

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

package/dist/components/roulette/RouletteControls/RouletteAuto.d.ts

@@ -0,0 +1,19 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class RouletteAuto extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    profitOnWin: string;
+    betDisabled: boolean;
+    isDesktop: boolean;
+    perClickAmount: string;
+    totalBetAmount: string;
+    maxPerClickAmount?: string;
+    noChips: boolean;
+    gameData?: gameContextType;
+    private isBetAmountValid;
+    private handlePerClickAmountChange;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/roulette/RouletteControls/RouletteControls.styles.d.ts

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

package/dist/components/roulette/RouletteControls/RouletteManual.d.ts

@@ -0,0 +1,17 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class RouletteManual extends OrigamiElement {
+    isPlaying: boolean;
+    betDisabled: boolean;
+    inputsDisabled: boolean;
+    noChips: boolean;
+    perClickAmount: string;
+    totalBetAmount: string;
+    maxPerClickAmount?: string;
+    gameData: gameContextType;
+    private isBetAmountValid;
+    private _betAboveBalance;
+    static styles: import('lit').CSSResult[];
+    private handlePerClickAmountChange;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/roulette/RouletteGame.d.ts

@@ -0,0 +1,37 @@
+import { AutobetSettingsWithId, GameBetResult } from '../shared/GameComponent';
+import { RouletteApi } from './roulette.api';
+import { MockRouletteApi } from './roulette.mock.api';
+import { RouletteType } from './roulette.constants';
+import { ChipEvent } from '../../shared/chip-state.utils';
+import { ChipTableGameComponent } from '../shared/ChipTableGameComponent';
+export declare class RouletteGame extends ChipTableGameComponent {
+    static styles: import('lit').CSSResult[];
+    private isManualPlaying;
+    private betResult;
+    private history;
+    private hitNumber;
+    private showMobileOverlay;
+    private displayedHitNumber;
+    private lastResultNumber;
+    private showWinPopup;
+    private newBalance;
+    private ballLandResolver;
+    private _manualEl?;
+    private _autoEl?;
+    constructor();
+    get rouletteType(): RouletteType;
+    get rouletteApi(): RouletteApi | MockRouletteApi;
+    get isToggleDisabled(): boolean;
+    get areInputsDisabled(): boolean;
+    get maxPossiblePayout(): number;
+    protected isMaxPayoutExceeded(chipEvents: ChipEvent[]): boolean;
+    private handleGridClick;
+    private addToHistory;
+    private extractHitNumberFromActions;
+    private applyBetResult;
+    private handleBetExecution;
+    private handleBallLand;
+    roulettePlay(): Promise<void>;
+    protected executeAutobet(autobetSettings: AutobetSettingsWithId, _currentBetAmount: string): Promise<GameBetResult>;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/roulette/RouletteGame.styles.d.ts

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

package/dist/components/roulette/RouletteGrid/RouletteGrid.d.ts

@@ -0,0 +1,21 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { RouletteType } from '../roulette.constants';
+export declare class RouletteGrid extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    placedChips: Map<string, number>;
+    rouletteType: RouletteType;
+    displayedHitNumber: number | null;
+    dimmed: boolean;
+    disabled: boolean;
+    private hoveredNumbers;
+    private handleChipPlace;
+    private getPositionFromEvent;
+    private onMouseOver;
+    private onGridLeave;
+    private onContextMenu;
+    private get isAmerican();
+    private isHitNumber;
+    private renderChipStack;
+    private renderNumberCell;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/roulette/RouletteGrid/RouletteGrid.styles.d.ts

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

package/dist/components/roulette/RouletteTop/RouletteTop.d.ts

@@ -0,0 +1,18 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { RouletteType } from '@betorigami/game-calculations';
+import { RouletteHistoryEntry } from '../roulette.constants';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class RouletteTop extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    rouletteType: RouletteType;
+    hitNumber: number | null;
+    canUndo: boolean;
+    isPlaying: boolean;
+    displayedHitNumber: number | null;
+    instantBetEnabled: boolean;
+    canClear: boolean;
+    history: RouletteHistoryEntry[];
+    get pastResults(): RouletteHistoryEntry[];
+    gameData?: gameContextType;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/roulette/RouletteTop/RouletteTop.styles.d.ts

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

package/dist/components/roulette/assets/index.d.ts

@@ -0,0 +1,2 @@
+export declare const rouletteWheelAmericanSvg: import('lit').TemplateResult<2>;
+export declare const rouletteWheelEuropeanSvg: import('lit').TemplateResult<2>;

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

@@ -0,0 +1,16 @@
+import { AutobetApiSettings, RouletteStartAction, StartBetResponse } from '../../shared/bet.types';
+import { Language } from '../../translations';
+export type RouletteStartArgs = {
+    language: Language;
+    meta?: {
+        autobetSettings: AutobetApiSettings;
+    };
+};
+export declare class RouletteApi {
+    private authToken;
+    private baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: RouletteStartArgs & {
+        gameInputs: RouletteStartAction;
+    }): Promise<StartBetResponse>;
+}

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

@@ -0,0 +1,57 @@
+export { RouletteType, Parity, Color, Half, Column, Dozen } from '@betorigami/game-calculations';
+export { BASE_UNIT_MULTIPLIER, CHIP_DENOMINATIONS } from '../../shared/chip-state.utils';
+export type { ChipConfig } from '../shared/types/chip.types';
+export interface RouletteHistoryEntry {
+    multiplier: number;
+    won: boolean;
+    id: string;
+    hitNumber: number;
+}
+export declare const MOBILE_CELL_SIZE = 40;
+export declare const MOBILE_GAP = 8;
+export declare const MOBILE_SCALE = 0.75;
+export declare const MOBILE_WHEEL_GAP = 12;
+export declare const RED_NUMBERS: Set<number>;
+/** European wheel: 37 numbers (0-36) in physical clockwise order */
+export declare const EUROPEAN_WHEEL_SEQUENCE: readonly [0, 32, 15, 19, 4, 21, 2, 25, 17, 34, 6, 27, 13, 36, 11, 30, 8, 23, 10, 5, 24, 16, 33, 1, 20, 14, 31, 9, 22, 18, 29, 7, 28, 12, 35, 3, 26];
+/** American wheel: 38 numbers (0, 00, 1-36) - 37 represents 00 */
+export declare const AMERICAN_WHEEL_SEQUENCE: readonly [0, 28, 9, 26, 30, 11, 7, 20, 32, 17, 5, 22, 34, 15, 3, 24, 36, 13, 1, 37, 27, 10, 25, 29, 12, 8, 19, 31, 18, 6, 21, 33, 16, 4, 23, 35, 14, 2];
+/** Ball circling radius in pixels */
+export declare const ROULETTE_BALL_RADIUS = 128;
+/** Ball angular velocity in degrees per frame */
+export declare const ROULETTE_ANGULAR_VELOCITY = 5;
+/** Total rotation during the ball falling animation (270 degrees) */
+export declare const ROULETTE_ROTATION_RADIANS: number;
+/** Angle threshold for starting the falling animation (degrees) */
+export declare const ROULETTE_ANGLE_THRESHOLD = 5;
+/** Ball offset angle adjustment (degrees) */
+export declare const ROULETTE_EUROPEAN_BALL_OFFSET = 187;
+export declare const ROULETTE_AMERICAN_BALL_OFFSET = 5;
+/** Position in the ball falling animation trajectory */
+export interface AnimationPosition {
+    x: number;
+    y: number;
+}
+/** Marker for when a bounce sound should play */
+export interface BounceCount {
+    bounceCount: number;
+}
+/** Union type for animation array elements */
+export type AnimationArrayType = AnimationPosition | BounceCount;
+/** Transformed position with polar coordinates for rendering */
+export interface PositionDetails {
+    x: number;
+    y: number;
+    angle: number;
+    length: number;
+}
+/**
+ * Ball falling animation arrays.
+ * First and last elements are always AnimationPosition (never BounceCount).
+ * BounceCount markers indicate when to play bounce sounds.
+ */
+export declare const ROULETTE_ANIMATION_ARR_1: AnimationArrayType[];
+export declare const ROULETTE_ANIMATION_ARR_2: AnimationArrayType[];
+export declare const ROULETTE_ANIMATION_ARR_3: AnimationArrayType[];
+/** All animation arrays for random selection */
+export declare const ROULETTE_ANIMATION_ARRAYS: readonly [AnimationArrayType[], AnimationArrayType[], AnimationArrayType[]];

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

@@ -0,0 +1,10 @@
+import { BetResult, RouletteStartAction } from '../../shared/bet.types';
+import { RouletteStartArgs } from './roulette.api';
+export declare class MockRouletteApi {
+    startBet(data: RouletteStartArgs & {
+        gameInputs: RouletteStartAction;
+    }): Promise<{
+        success: true;
+        data: BetResult;
+    }>;
+}

package/dist/components/roulette/roulette.positions.d.ts

@@ -0,0 +1,58 @@
+import { RouletteType } from '@betorigami/game-calculations';
+export declare const Pos: {
+    readonly straight: (n: number) => string;
+    readonly split: (a: number, b: number) => string;
+    readonly street: (a: number, b: number, c: number) => string;
+    readonly corner: (a: number, b: number, c: number, d: number) => string;
+    readonly line: (a: number, b: number, c: number, d: number, e: number, f: number) => string;
+    readonly dozen: (which: "FIRST" | "SECOND" | "THIRD") => string;
+    readonly half: (which: "LOW" | "HIGH") => string;
+    readonly parity: (which: "EVEN" | "ODD") => string;
+    readonly color: (which: "RED" | "BLACK") => string;
+    readonly column: (which: "TOP" | "MIDDLE" | "BOTTOM") => string;
+    readonly basket: () => string;
+};
+export type ParsedPosition = {
+    type: 'straight';
+    value: number;
+} | {
+    type: 'split';
+    values: readonly [number, number];
+} | {
+    type: 'street';
+    values: readonly [number, number, number];
+} | {
+    type: 'corner';
+    values: readonly [number, number, number, number];
+} | {
+    type: 'line';
+    values: readonly [number, number, number, number, number, number];
+} | {
+    type: 'dozen';
+    dozen: 'FIRST' | 'SECOND' | 'THIRD';
+} | {
+    type: 'half';
+    half: 'LOW' | 'HIGH';
+} | {
+    type: 'parity';
+    parity: 'EVEN' | 'ODD';
+} | {
+    type: 'color';
+    color: 'RED' | 'BLACK';
+} | {
+    type: 'column';
+    column: 'TOP' | 'MIDDLE' | 'BOTTOM';
+} | {
+    type: 'basket';
+};
+export declare function parsePosition(position: string): ParsedPosition | null;
+export declare const VALID_EUROPEAN_POSITIONS: Set<string>;
+export declare const VALID_AMERICAN_POSITIONS: Set<string>;
+export declare function isValidPosition(position: string, type: RouletteType): boolean;
+export declare function getRowIndex(n: number): 0 | 1 | 2;
+export declare function getVerticalSplitPosition(n: number, type: RouletteType): string | null;
+export declare function getHorizontalSplitPosition(n: number, type: RouletteType): string | null;
+export declare function getCornerPosition(n: number, type: RouletteType): string | null;
+export declare function getDoubleStreetPosition(n: number, type: RouletteType): string | null;
+export declare function getStreetPosition(n: number, type: RouletteType): string | null;
+export declare function getCoveredNumbers(position: string): number[];

package/dist/components/roulette/roulette.transformer.d.ts

@@ -0,0 +1,4 @@
+import { RouletteStartAction } from '../../shared/bet.types';
+import { RouletteType } from './roulette.constants';
+export declare function transformGridBetsToApiFormat(placedBets: Map<string, number>, rouletteType?: RouletteType): RouletteStartAction;
+export declare function calculateTotalBetAmount(placedBets: Map<string, number>): number;

package/dist/components/roulette/roulette.utils.d.ts

@@ -0,0 +1,24 @@
+import { RouletteType } from '@betorigami/game-calculations';
+import { AnimationArrayType, PositionDetails, BounceCount } from './roulette.constants';
+export { getCoveredNumbers } from './roulette.positions';
+export declare class RouletteUtils {
+    static getNumberColor(n: number): 'red' | 'black' | 'green';
+    static getValidSplits(type: RouletteType): readonly [readonly [0, 1], readonly [0, 2], readonly [0, 3], readonly [1, 2], readonly [1, 4], readonly [2, 3], readonly [2, 5], readonly [3, 6], readonly [4, 5], readonly [4, 7], readonly [5, 6], readonly [5, 8], readonly [6, 9], readonly [7, 8], readonly [7, 10], readonly [8, 9], readonly [8, 11], readonly [9, 12], readonly [10, 11], readonly [10, 13], readonly [11, 12], readonly [11, 14], readonly [12, 15], readonly [13, 14], readonly [13, 16], readonly [14, 15], readonly [14, 17], readonly [15, 18], readonly [16, 17], readonly [16, 19], readonly [17, 18], readonly [17, 20], readonly [18, 21], readonly [19, 20], readonly [19, 22], readonly [20, 21], readonly [20, 23], readonly [21, 24], readonly [22, 23], readonly [22, 25], readonly [23, 24], readonly [23, 26], readonly [24, 27], readonly [25, 26], readonly [25, 28], readonly [26, 27], readonly [26, 29], readonly [27, 30], readonly [28, 29], readonly [28, 31], readonly [29, 30], readonly [29, 32], readonly [30, 33], readonly [31, 32], readonly [31, 34], readonly [32, 33], readonly [32, 35], readonly [33, 36], readonly [34, 35], readonly [35, 36]] | readonly [readonly [0, 1], readonly [0, 37], readonly [3, 37], readonly [1, 2], readonly [1, 4], readonly [2, 3], readonly [2, 5], readonly [3, 6], readonly [4, 5], readonly [4, 7], readonly [5, 6], readonly [5, 8], readonly [6, 9], readonly [7, 8], readonly [7, 10], readonly [8, 9], readonly [8, 11], readonly [9, 12], readonly [10, 11], readonly [10, 13], readonly [11, 12], readonly [11, 14], readonly [12, 15], readonly [13, 14], readonly [13, 16], readonly [14, 15], readonly [14, 17], readonly [15, 18], readonly [16, 17], readonly [16, 19], readonly [17, 18], readonly [17, 20], readonly [18, 21], readonly [19, 20], readonly [19, 22], readonly [20, 21], readonly [20, 23], readonly [21, 24], readonly [22, 23], readonly [22, 25], readonly [23, 24], readonly [23, 26], readonly [24, 27], readonly [25, 26], readonly [25, 28], readonly [26, 27], readonly [26, 29], readonly [27, 30], readonly [28, 29], readonly [28, 31], readonly [29, 30], readonly [29, 32], readonly [30, 33], readonly [31, 32], readonly [31, 34], readonly [32, 33], readonly [32, 35], readonly [33, 36], readonly [34, 35], readonly [35, 36]];
+    static getValidStreets(type: RouletteType): readonly [readonly [0, 1, 2], readonly [0, 2, 3], readonly [1, 2, 3], readonly [4, 5, 6], readonly [7, 8, 9], readonly [10, 11, 12], readonly [13, 14, 15], readonly [16, 17, 18], readonly [19, 20, 21], readonly [22, 23, 24], readonly [25, 26, 27], readonly [28, 29, 30], readonly [31, 32, 33], readonly [34, 35, 36]] | readonly [readonly [0, 1, 2], readonly [0, 2, 37], readonly [1, 2, 3], readonly [2, 3, 37], readonly [4, 5, 6], readonly [7, 8, 9], readonly [10, 11, 12], readonly [13, 14, 15], readonly [16, 17, 18], readonly [19, 20, 21], readonly [22, 23, 24], readonly [25, 26, 27], readonly [28, 29, 30], readonly [31, 32, 33], readonly [34, 35, 36]];
+    static getValidCorners(type: RouletteType): readonly [readonly [0, 1, 2, 3], readonly [1, 2, 4, 5], readonly [2, 3, 5, 6], readonly [4, 5, 7, 8], readonly [5, 6, 8, 9], readonly [7, 8, 10, 11], readonly [8, 9, 11, 12], readonly [10, 11, 13, 14], readonly [11, 12, 14, 15], readonly [13, 14, 16, 17], readonly [14, 15, 17, 18], readonly [16, 17, 19, 20], readonly [17, 18, 20, 21], readonly [19, 20, 22, 23], readonly [20, 21, 23, 24], readonly [22, 23, 25, 26], readonly [23, 24, 26, 27], readonly [25, 26, 28, 29], readonly [26, 27, 29, 30], readonly [28, 29, 31, 32], readonly [29, 30, 32, 33], readonly [31, 32, 34, 35], readonly [32, 33, 35, 36]] | readonly [readonly [1, 2, 4, 5], readonly [2, 3, 5, 6], readonly [4, 5, 7, 8], readonly [5, 6, 8, 9], readonly [7, 8, 10, 11], readonly [8, 9, 11, 12], readonly [10, 11, 13, 14], readonly [11, 12, 14, 15], readonly [13, 14, 16, 17], readonly [14, 15, 17, 18], readonly [16, 17, 19, 20], readonly [17, 18, 20, 21], readonly [19, 20, 22, 23], readonly [20, 21, 23, 24], readonly [22, 23, 25, 26], readonly [23, 24, 26, 27], readonly [25, 26, 28, 29], readonly [26, 27, 29, 30], readonly [28, 29, 31, 32], readonly [29, 30, 32, 33], readonly [31, 32, 34, 35], readonly [32, 33, 35, 36]];
+    static findValidSplit(numbers: number[], type?: RouletteType): readonly [number, number] | null;
+    static findValidStreet(numbers: number[], type?: RouletteType): readonly [number, number, number] | null;
+    static findValidCorner(numbers: number[], type?: RouletteType): readonly [number, number, number, number] | null;
+    static getWheelSequence(type: RouletteType): readonly number[];
+    static calculateBallTargetAngle(hitNumber: number, type?: RouletteType): number;
+    static getRandomAnimationArray(): AnimationArrayType[];
+    static transformAnimationPosition(val: AnimationArrayType, arr: AnimationArrayType[]): PositionDetails | BounceCount;
+    static preprocessAnimationArray(arr: AnimationArrayType[]): (PositionDetails | BounceCount)[];
+    static getBallOffset(type: RouletteType): number;
+    private static convertBetsToLibraryFormat;
+    private static preparePayoutInputs;
+    static findMaxPayoutTile(state: Map<string, number>, rouletteType: RouletteType): {
+        maxPayout: number;
+        positionOfMaxMultiplier: number;
+    };
+}

package/dist/components/shared/Alert/Alert.d.ts

@@ -0,0 +1,27 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../context/game.context';
+export type AlertType = 'success' | 'warning' | 'error' | 'info';
+export declare class Alert extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    type: AlertType;
+    message: string;
+    autoCloseDelay: number;
+    flipToRefreshTimer: boolean;
+    private isHiding;
+    private isPaused;
+    private progressWidth;
+    gameData?: gameContextType;
+    private animationFrame?;
+    private remainingTime;
+    private lastTickTimestamp?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    handleAutoCloseDelayChange(): void;
+    private initializeTimer;
+    private startTimer;
+    private clearTimer;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    private handleClose;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Alert/Alert.styles.d.ts

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

package/dist/components/shared/AlertManager/AlertManager.d.ts

@@ -0,0 +1,28 @@
+import { nothing } from 'lit';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { AlertType } from '../Alert/Alert';
+import { gameContextType } from '../context/game.context';
+export interface AlertItem {
+    id: string;
+    type: AlertType;
+    message: string;
+    autoCloseDelay?: number;
+    showCloseButton?: boolean;
+    flipToRefreshTimer?: boolean;
+}
+export declare class AlertManager extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    gameData?: gameContextType;
+    private alerts;
+    private previousPositions;
+    private readonly defaultAnimationMs;
+    addAlert(alert: AlertItem): string;
+    clearAllAlerts(): void;
+    private handleAlertClose;
+    render(): typeof nothing | import('lit').TemplateResult<1>;
+    protected willUpdate(): void;
+    protected updated(): void;
+    private measurePositions;
+    private getAnimationDurationMs;
+    private playFlipAnimations;
+}

package/dist/components/shared/AlertManager/AlertManager.styles.d.ts

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

package/dist/components/shared/BetDetailsComponent/BetDetailsComponent.d.ts

@@ -0,0 +1,21 @@
+import { TemplateResult } from 'lit';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Language } from '../../../translations';
+export declare class BetDetailsComponent extends OrigamiElement {
+    static styles: import('lit').CSSResult;
+    baseUrl: string;
+    betId: string;
+    language: Language;
+    private _betDetails;
+    private get _gameName();
+    private get _roundId();
+    private get _timestamp();
+    private get _currency();
+    private get _betAmount();
+    private get _multiplier();
+    private get _payout();
+    render(): TemplateResult<1>;
+    connectedCallback(): Promise<void>;
+    private handleShare;
+    private fetchBetDetails;
+}

package/dist/components/shared/BetDetailsComponent/BetDetailsComponent.styles.d.ts

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

package/dist/components/shared/BetResultModal/BetResultDataExtractor.d.ts

@@ -0,0 +1,75 @@
+import { BetResult } from '../../../shared/bet.types';
+import { RollType, Bounds } from '../../advanced-dice/advanced-dice.types';
+import { DiceData as DiceDisplayData, KenoData as KenoDisplayData, LimboData as LimboDisplayData, MinesData as MinesDisplayData, DiamondsData as DiamondsDisplayData, WheelData, PlinkoData, RouletteData, BaccaratData, BlackjackData, BlitzData } from '../GameOutcomeDisplay/GameOutcomeDisplay';
+interface DiceRawData {
+    resultValue: number;
+    userValue: number;
+    isRollLower: boolean;
+    winChance: string;
+    isDiceWin: boolean;
+}
+interface AdvancedDiceRawData {
+    resultValue: number;
+    rollType: RollType;
+    bounds: Bounds;
+    secondBounds?: Bounds;
+    winChance: string;
+    isWin: boolean;
+}
+export interface AdvancedDiceDisplayData {
+    resultValue: number;
+    rollType: RollType;
+    firstBoundsLower: number;
+    firstBoundsUpper: number;
+    secondBoundsLower?: number;
+    secondBoundsUpper?: number;
+    isWin: boolean;
+}
+export declare class BetResultDataExtractor {
+    private betData;
+    readonly minesDisplayData: MinesDisplayData;
+    readonly limboDisplayData: LimboDisplayData;
+    readonly diceDisplayData: DiceDisplayData;
+    readonly kenoDisplayData: KenoDisplayData;
+    readonly diamondsDisplayData: DiamondsDisplayData;
+    readonly wheelDisplayData: WheelData;
+    readonly diceRawData: DiceRawData;
+    readonly advancedDiceRawData: AdvancedDiceRawData;
+    readonly advancedDiceDisplayData: AdvancedDiceDisplayData;
+    readonly rouletteDisplayData: RouletteData;
+    readonly baccaratDisplayData: BaccaratData;
+    readonly blackjackDisplayData: BlackjackData;
+    readonly blitzDisplayData: BlitzData;
+    readonly blitzPickCount: number;
+    constructor(betData: Omit<BetResult, 'afterBalance'>);
+    private _computeDiceRawData;
+    private _computeMinesDisplayData;
+    private _computeKenoDisplayData;
+    private _computeLimboDisplayData;
+    private _computeDiamondsDisplayData;
+    private _computeDiceDisplayData;
+    private _computeWheelDisplayData;
+    private _computeAdvancedDiceRawData;
+    private _computeAdvancedDiceDisplayData;
+    getMinesDisplayData(): MinesDisplayData;
+    getLimboDisplayData(): LimboDisplayData;
+    getDiceDisplayData(): DiceDisplayData;
+    getKenoDisplayData(): KenoDisplayData;
+    getDiamondsDisplayData(): DiamondsDisplayData;
+    getWheelDisplayData(): WheelData;
+    getDiceData(): DiceRawData;
+    getAdvancedDiceDisplayData(): AdvancedDiceDisplayData;
+    getAdvancedDiceRawData(): AdvancedDiceRawData;
+    getPlinkoDisplayData(): PlinkoData;
+    private _computeRouletteDisplayData;
+    getRouletteDisplayData(): RouletteData;
+    private _computeBaccaratDisplayData;
+    getBaccaratDisplayData(): BaccaratData;
+    private _computeBlackjackDisplayData;
+    getBlackjackDisplayData(): BlackjackData;
+    private _computeBlitzDisplayData;
+    getBlitzDisplayData(): BlitzData;
+    private _computeBlitzPickCount;
+    getBlitzPickCount(): number;
+}
+export {};