@betorigami/games 2.10.1 → 2.11.0

package/dist/components/dice/dice-calculations.d.ts

@@ -0,0 +1,28 @@
+import { DiceDirection } from '../../shared/calculations/games/dice';
+import { default as Big } from 'big.js';
+export declare class DiceCalculations {
+    static totalDiceValue: number;
+    static minWinChance: number;
+    static inputValuePrecision: number;
+    static getMaxWinChance(edge: number, minMultiplier: number | null): number;
+    static getMultiplier(edge: number, selectedValue: number, diceDirection: DiceDirection): string;
+    static getWinChance(selectedValue: number, diceDirection: DiceDirection): string;
+    static getSelectedValueFromMultiplier(edge: number, multiplier: Big.BigSource, diceDirection: DiceDirection): number;
+    static getSelectedValueFromWinChance(winChancePercentage: Big.BigSource, diceDirection: DiceDirection): number;
+    private static isSelectableBelow;
+    private static getBelowSelectableBounds;
+    static getMinSelectableValue(edge: number, diceDirection: DiceDirection, minMultiplier: number | null): number;
+    static getMaxSelectableValue(edge: number, diceDirection: DiceDirection, minMultiplier: number | null): number;
+    static clampSelectedValue(selectedValue: number, edge: number, diceDirection: DiceDirection, minMultiplier: number | null): number;
+    static getSelectedValueFromRollOver(selectedValue: number): number;
+    static getSliderMin(edge: number, diceDirection: DiceDirection, minMultiplier: number | null): number;
+    static getSliderMax(edge: number, diceDirection: DiceDirection, minMultiplier: number | null): number;
+    static getRollRange(edge: number, diceDirection: DiceDirection, minMultiplier: number | null): {
+        min: number;
+        max: number;
+    };
+    static getMinMultiplier(edge: number, minMultiplier: number | null): string;
+    static getMaxMultiplier(edge: number): string;
+    static isValidMultiplier(edge: number, multiplier: string, minMultiplier: number | null): boolean;
+    static isValidWinChance(winChance: string, edge: number, minMultiplier: number | null): boolean;
+}

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

@@ -0,0 +1,18 @@
+import { BaseStartArgs } from '../../shared/bet.types';
+import { DiceDirection } from '../../shared/calculations/games/dice';
+import { SuccessBetResult, ErrorBetResult } from '../../shared/provider-api/bet-result';
+export interface DiceStartArgs extends BaseStartArgs {
+    direction: DiceDirection;
+    selectedValue: number;
+}
+export type SuccessDiceBetResult = SuccessBetResult<number>;
+export type DiceBetResult = SuccessDiceBetResult | ErrorBetResult;
+export interface IDiceApi {
+    startBet(data: DiceStartArgs): Promise<DiceBetResult>;
+}
+export declare class DiceApi implements IDiceApi {
+    private readonly authToken;
+    private readonly baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: DiceStartArgs): Promise<DiceBetResult>;
+}

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

@@ -0,0 +1,10 @@
+import { DiceBetResult, DiceStartArgs, IDiceApi } from './dice.api';
+export declare class MockDiceApi implements IDiceApi {
+    private readonly getEdge;
+    private readonly getBalance;
+    private readonly getMinMultiplier;
+    constructor(getEdge: () => number, getBalance: () => number, getMinMultiplier: () => number | null);
+    private isValidSelectedValue;
+    startBet(data: DiceStartArgs): Promise<DiceBetResult>;
+    private static getRandomValueInRange;
+}

package/dist/components/keno/KenoContent/KenoContent.d.ts

@@ -0,0 +1,20 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { KenoRiskLevel } from '../../../shared/calculations/games/keno';
+import { default as Big } from 'big.js';
+export declare class KenoContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    selectedTiles: number[];
+    resultTiles: number[];
+    isPlaying: boolean;
+    gameOver: boolean;
+    multipliersForSelectedTiles: number;
+    payout: Big | null;
+    gameWinPopupShowing: boolean;
+    multiplier: number;
+    risk: KenoRiskLevel;
+    betAmount: string;
+    betId?: string;
+    isDesktop: boolean;
+    get hitCount(): number;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/keno/KenoContent/KenoContent.styles.d.ts

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

package/dist/components/keno/KenoContentBottom/KenoContentBottom.d.ts

@@ -0,0 +1,21 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { KenoRiskLevel } from '../../../shared/calculations/games/keno';
+export declare class KenoContentBottom extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    isDesktop: boolean;
+    selectedTiles: number[];
+    risk: KenoRiskLevel;
+    betAmount: string;
+    hitCount: number;
+    multipliersForSelectedTiles: number;
+    resultTiles: number[];
+    private hoverItemIndex;
+    gameData: gameContextType;
+    updated(changedProperties: Map<string, any>): void;
+    private scrollToHighlightedGem;
+    private formatMultiplier;
+    handleMouseOver(index: number, event: MouseEvent): void;
+    handleMouseLeave(): void;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/keno/KenoContentBottom/KenoContentBottom.styles.d.ts

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

package/dist/components/keno/KenoControls/KenoAuto.d.ts

@@ -0,0 +1,16 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { KenoRiskLevel } from '../../../shared/calculations/games/keno';
+export declare class KenoAuto extends OrigamiElement {
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    disableBet: boolean;
+    readonly autobetInProgress = false;
+    selectedTilesCount: number;
+    isDesktop: boolean;
+    betMaxMultiplier: number;
+    risk: KenoRiskLevel;
+    gameData?: gameContextType;
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/keno/KenoControls/KenoControls.styles.d.ts

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

package/dist/components/keno/KenoControls/KenoManual.d.ts

@@ -0,0 +1,16 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { KenoRiskLevel } from '../../../shared/calculations/games/keno';
+export declare class KenoManual extends OrigamiElement {
+    inputsDisabled: boolean;
+    risk: KenoRiskLevel;
+    isPlaying: boolean;
+    disableBet: boolean;
+    selectedTilesCount: number;
+    betMaxMultiplier: number;
+    gameData?: gameContextType;
+    private isBetAmountValid;
+    private _betAboveBalance;
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/keno/KenoGame.d.ts

@@ -0,0 +1,52 @@
+import { KenoRiskChangeEvent, KenoTileClickEvent } from '../../shared/event-map';
+import { AutobetSettingsWithId, GameBetResult, GameComponent } from '../shared/GameComponent';
+import { KenoApi } from './keno.api';
+import { MockKenoApi } from './keno.mock.api';
+export interface KenoHistory {
+    multiplier: number;
+    won: boolean;
+    id: string;
+}
+export declare class KenoGame extends GameComponent {
+    private isManualPlaying;
+    private history;
+    private selectedTiles;
+    private resultTiles;
+    gameWinPopupShowing: boolean;
+    static styles: import('lit').CSSResult[];
+    private gameOver;
+    private payout;
+    private kenoRisk;
+    private multiplier;
+    private betId;
+    private showResetAnimation;
+    private _kenoManualEl?;
+    private _kenoAutoEl?;
+    private get kenoEdge();
+    private getDisplayMultiplier;
+    get isToggleDisabled(): boolean;
+    get areInputsDisabled(): boolean;
+    get kenoApi(): KenoApi | MockKenoApi;
+    private _getGemPitchFromHits;
+    private playGemRevealFeedback;
+    private playLossGemRevealFeedback;
+    private playAnimatedRevealFeedback;
+    kenoPlay(): Promise<void>;
+    private handleBetExecution;
+    addToHistory(multiplier: number, won: boolean, id: string): void;
+    protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
+    handleTileClick: (e: KenoTileClickEvent) => void;
+    handleRiskChange: (e: KenoRiskChangeEvent) => void;
+    autoPick: () => void;
+    clearTable: () => void;
+    newGame: () => void;
+    render(): import('lit').TemplateResult<1>;
+    private getButton;
+    private clickButton;
+    private isButtonDisabled;
+    private handleSpacebar;
+    private handleAutoPick;
+    private handleClearTable;
+    constructor();
+    firstUpdated(changedProperties: Map<string | number | symbol, unknown>): Promise<void>;
+}

package/dist/components/keno/KenoGame.styles.d.ts

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

package/dist/components/keno/KenoGrid/KenoGrid.d.ts

@@ -0,0 +1,18 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class KenoGrid extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    selectedTiles: number[];
+    resultTiles: number[];
+    popupShowing: boolean;
+    isPlaying: boolean;
+    gameOver: boolean;
+    enableSounds: boolean;
+    ariaLabel: string;
+    gameData?: gameContextType;
+    isDesktop: boolean;
+    get selectedCount(): number;
+    get hitCount(): number;
+    private calculateTileState;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/keno/KenoGrid/KenoGrid.styles.d.ts

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

package/dist/components/keno/KenoTile/KenoTile.d.ts

@@ -0,0 +1,19 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare enum KenoTileState {
+    NORMAL = "NORMAL",
+    SELECTED = "SELECTED",
+    LOSS = "LOSS",
+    WIN = "WIN"
+}
+export declare class KenoTile extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    number: number;
+    state: KenoTileState;
+    disabled: boolean;
+    ariaLabel: string;
+    gameData?: gameContextType;
+    private handlePointerDown;
+    private handleClick;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/keno/KenoTile/KenoTile.styles.d.ts

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

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

@@ -0,0 +1,24 @@
+import { BaseStartArgs } from '../../shared/bet.types';
+import { Language } from '../../translations';
+import { KenoRiskLevel } from '../../shared/calculations/games/keno';
+export declare const MAX_SELECTABLE_TILES = 10;
+export declare const TOTAL_KENO_TILES = 40;
+export interface KenoStartArgs extends BaseStartArgs {
+    language: Language;
+    riskLevel: KenoRiskLevel;
+    selectedNumbers: number[];
+}
+export declare class KenoApi {
+    private authToken;
+    private baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: KenoStartArgs): Promise<{
+        success: true;
+        data: any;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        data?: undefined;
+    }>;
+}

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

@@ -0,0 +1,19 @@
+import { BetResult } from '../../shared/bet.types';
+import { KenoStartArgs } from './keno.api';
+import { KenoEdge } from '../../shared/calculations/games/keno';
+export interface MockKenoSettings {
+    shouldWin?: boolean;
+    resultTiles?: number[];
+    multiplier?: number;
+    hitCount?: number;
+}
+export declare class MockKenoApi {
+    private readonly edge;
+    constructor(edge: KenoEdge);
+    startBet(data: KenoStartArgs): Promise<{
+        success: true;
+        data: BetResult;
+    }>;
+    private static generateRandomTiles;
+    private calculateMultiplier;
+}

package/dist/components/limbo/LimboContent/LimboContent.d.ts

@@ -0,0 +1,21 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { LimboHistory } from '../LimboGame';
+import { SoundEffectsController } from '../../../controllers/sound/sound-effects.controller';
+export declare class LimboContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    targetMultiplier: number;
+    betTargetMultiplier: number;
+    history: LimboHistory[];
+    resultMultiplier: number | null;
+    betId: string;
+    isPlaying: boolean;
+    isDesktop: boolean;
+    disableSound: boolean;
+    language: import('../../..').Language;
+    edge: 1 | 2 | 3 | 4 | 8;
+    customLimboBackgroundSvgUrl: string;
+    instantBetEnabled: boolean;
+    soundEffects?: SoundEffectsController;
+    private get _multiplierBgStyle();
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/limbo/LimboContent/LimboContent.styles.d.ts

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

package/dist/components/limbo/LimboContentBottom/LimboContentBottom.d.ts

@@ -0,0 +1,21 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Language } from '../../../translations';
+export declare class LimboContentBottom extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    targetMultiplier: number;
+    disabled: boolean;
+    language: Language;
+    edge: 1 | 2 | 3 | 4 | 8;
+    winChanceInputFocused: boolean;
+    multiplierInputFocused: boolean;
+    private _winChanceInputValue;
+    private _multiplierInputValue;
+    _previousMultiplierInputValue: string;
+    _previousWinChanceInputValue: string;
+    set winChanceInputValue(value: string);
+    set multiplierInputValue(value: string);
+    setWinChanceValue(value: string): void;
+    setMultiplierValue(value: string): void;
+    targetMultiplierChanged(): void;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/limbo/LimboContentBottom/LimboContentBottom.styles.d.ts

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

package/dist/components/limbo/LimboControls/LimboAuto.d.ts

@@ -0,0 +1,13 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class LimboAuto extends OrigamiElement {
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    betDisabled: boolean;
+    isDesktop: boolean;
+    betMaxMultiplier: number;
+    private genericAutobetEl?;
+    triggerPrimaryAction(): void;
+    isPrimaryActionDisabled(): boolean;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/limbo/LimboControls/LimboControls.styles.d.ts

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

package/dist/components/limbo/LimboControls/LimboManual.d.ts

@@ -0,0 +1,19 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Language } from '../../../translations';
+import { Currency } from '../../../shared/constants';
+export declare class LimboManual extends OrigamiElement {
+    inputsDisabled: boolean;
+    isPlaying: boolean;
+    profitOnWin: string;
+    betDisabled: boolean;
+    betMaxMultiplier: number;
+    language: Language;
+    currency: Currency;
+    private isBetAmountValid;
+    private _betAboveBalance;
+    private actionButtonEl?;
+    static styles: import('lit').CSSResult[];
+    triggerPrimaryAction(): void;
+    isPrimaryActionDisabled(): boolean;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/limbo/LimboGame.d.ts

@@ -0,0 +1,37 @@
+import { LimboMultiplierAnimationEndEvent, LimboMultiplierChangeEvent } from '../../shared/event-map';
+import { AutobetSettingsWithId, GameBetResult, GameComponent } from '../shared/GameComponent';
+export interface LimboHistory {
+    multiplier: number;
+    won: boolean;
+    id: string;
+}
+export declare class LimboGame extends GameComponent {
+    static styles: import('lit').CSSResult[];
+    private targetMultiplier;
+    private resultMultiplier;
+    private isManualPlaying;
+    private history;
+    private betTargetMultiplier;
+    private betId;
+    private _multiplierInputValid;
+    private _winChanceInputValid;
+    private _limboManualEl?;
+    private _limboAutoEl?;
+    get isToggleDisabled(): boolean;
+    get areInputsDisabled(): boolean;
+    private readonly getLimboApi;
+    constructor();
+    limboPlay(): Promise<void>;
+    private handleBetExecution;
+    private static readonly ANIMATION_TIMEOUT_MS;
+    private awaitRevealAnimation;
+    private waitForAnimationComplete;
+    private isSpacebarDisabled;
+    private handleSpacebar;
+    protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
+    multiplierChange: (e: LimboMultiplierChangeEvent) => void;
+    calculateProfitOnWin(): string;
+    addToHistory(multiplier: number, won: boolean, id: string): void;
+    multiplierAnimationEnd: (e: LimboMultiplierAnimationEndEvent) => void;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/limbo/LimboGame.styles.d.ts

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

package/dist/components/limbo/Multiplier/LimboMultiplier.d.ts

@@ -0,0 +1,27 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { SoundEffectsController } from '../../../controllers/sound/sound-effects.controller';
+export declare class LimboMultiplier extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    resultMultiplier: number | null;
+    betId: string;
+    betTargetMultiplier: number;
+    disableAnimation: boolean;
+    disableSound: boolean;
+    inGameDisplay: boolean;
+    ignoreInstantBet: boolean;
+    instantBetEnabled: boolean;
+    soundEffects?: SoundEffectsController;
+    private currentValue;
+    private isAnimating;
+    private queuedMultiplier;
+    private animationFrame;
+    private startTime;
+    private lastTickTime;
+    private get reduceMotionEnabled();
+    updated(changedProperties: Map<PropertyKey, unknown>): void;
+    disconnectedCallback(): void;
+    private startAnimation;
+    private updateAnimation;
+    private _getMultiplierColor;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/limbo/Multiplier/LimboMultiplier.styles.d.ts

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

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

@@ -0,0 +1,29 @@
+import { default as Big } from 'big.js';
+import { BaseStartArgs } from '../../shared/bet.types';
+import { SuccessBetResult, ErrorBetResult } from '../../shared/provider-api/bet-result';
+export interface LimboStartArgs extends BaseStartArgs {
+    targetMultiplier: number;
+}
+export type SuccessLimboBetResult = SuccessBetResult<number> & {
+    readonly resultMultiplier: Big;
+};
+export type LimboBetResult = SuccessLimboBetResult | ErrorBetResult;
+export interface ILimboApi {
+    startBet(data: LimboStartArgs): Promise<LimboBetResult>;
+}
+export declare class LimboApi implements ILimboApi {
+    private readonly authToken;
+    private readonly baseUrl;
+    static winChancePrecision: number;
+    static multiplierPrecision: number;
+    static minMultiplier: number;
+    static maxMultiplier: number;
+    static getMinWinChance(edge: number): string;
+    static getMaxWinChance(edge: number): string;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: LimboStartArgs): Promise<LimboBetResult>;
+    static calculateMultiplier(winChance: number, edge: number): string;
+    static calculateWinChance(targetMultiplier: number, edge: number): string;
+    static isValidMultiplier(multiplier: string): boolean;
+    static isValidWinChance(winChance: string, edge: number): boolean;
+}

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

@@ -0,0 +1,8 @@
+import { ILimboApi, LimboStartArgs, LimboBetResult } from './limbo.api';
+export declare class MockLimboApi implements ILimboApi {
+    private readonly getEdge;
+    private readonly getBalance;
+    constructor(getEdge: () => number, getBalance: () => number);
+    startBet(data: LimboStartArgs): Promise<LimboBetResult>;
+    private isValidTargetMultiplier;
+}

package/dist/components/mines/MinesControls/MinesAuto.d.ts

@@ -0,0 +1,18 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Language } from '../../../translations';
+export declare class MinesAuto extends OrigamiElement {
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    minesCount: number;
+    betDisabled: boolean;
+    isDesktop: boolean;
+    betMaxMultiplier: number;
+    language: Language;
+    private genericAutobetEl?;
+    static styles: import('lit').CSSResult[];
+    private handleMinesCountChange;
+    triggerPrimaryAction(): void;
+    isPrimaryActionDisabled(): boolean;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

package/dist/components/mines/MinesControls/MinesManual.d.ts

@@ -0,0 +1,32 @@
+import { Currency } from '../../../shared/constants';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Language } from '../../../translations';
+import { MinesState } from '../mines.constants';
+export declare class MinesManual extends OrigamiElement {
+    inputsDisabled: boolean;
+    minesState: MinesState | null;
+    isGameActive: boolean;
+    isLoading: boolean;
+    minesCount: number;
+    isSelectingRandomTile: boolean;
+    isTileLoading: boolean;
+    language: Language;
+    currency: Currency;
+    profitOnWin: string;
+    nextProfitOnWin: string;
+    nextMultiplier: string;
+    formattedPayout: string;
+    private isBetAmountValid;
+    private _betAboveBalance;
+    private actionButtonEl?;
+    triggerPrimaryAction(): void;
+    isPrimaryActionDisabled(): boolean;
+    static styles: import('lit').CSSResult[];
+    private get actionDisabled();
+    private get hasSelectedTiles();
+    triggerRandomTileAction(): void;
+    isRandomTileActionDisabled(): boolean;
+    triggerCashoutAction(): void;
+    isCashoutActionDisabled(): boolean;
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,48 @@
+import { AutobetToggleEvent } from '../../shared/event-map';
+import { AutobetSettingsWithId, GameBetResult, GameComponent } from '../shared/GameComponent';
+import { MinesState } from './mines.constants';
+export declare class MinesGame extends GameComponent {
+    private minesCount;
+    private autobetSelectedTiles;
+    private minesData;
+    private isLoading;
+    private isSelectingRandomTile;
+    private isCheckingForSession;
+    private loadingTiles;
+    static styles: import('lit').CSSResult[];
+    private _minesManualEl?;
+    private _minesAutoEl?;
+    private readonly sessionWatcher;
+    get isToggleDisabled(): boolean;
+    get areInputsDisabled(): boolean;
+    get isGameActive(): boolean;
+    private readonly getMinesApi;
+    get minesState(): MinesState | null;
+    private gameOutcomeFromMinesOutcome;
+    private deriveManualControlValues;
+    private playTileSound;
+    private gemPitchFromHits;
+    private playGemReveal;
+    getMinesActiveBet(): Promise<void>;
+    firstUpdated(changedProperties: Map<string | number | symbol, unknown>): Promise<void>;
+    protected updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
+    toggleAutobet(event: AutobetToggleEvent): Promise<void>;
+    private readonly minesClickHandler;
+    minesManualStart(): Promise<void>;
+    minesChooseRandomTile(): Promise<void>;
+    minesNext(selectedTile: number): Promise<void>;
+    minesCashout(): Promise<void>;
+    onManualOrAutoChange(): void;
+    onMinesCountChange(): void;
+    onAutobetChange(): void;
+    private isSpacebarDisabled;
+    private handleSpacebar;
+    private isRandomTileHotkeyDisabled;
+    private handleRandomTileHotkey;
+    private isCashoutHotkeyDisabled;
+    private handleCashoutHotkey;
+    private waitForAnimationsComplete;
+    constructor();
+    render(): import('lit').TemplateResult<1>;
+}

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

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

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

@@ -0,0 +1,26 @@
+import { HapticsController } from '../../../controllers/haptics.controller';
+import { SoundEffectsController } from '../../../controllers/sound/sound-effects.controller';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Language } from '../../../translations';
+import { MinesState } from '../mines.constants';
+export declare class MinesGrid extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    isAuto: boolean;
+    autobetSelectedTiles: number[];
+    autobetInProgress: boolean;
+    minesState: Partial<MinesState> | null;
+    hasWon: boolean;
+    hitBomb: boolean;
+    loadingTiles: number[];
+    isDesktop: boolean;
+    language: Language;
+    soundEffects?: SoundEffectsController;
+    haptics?: HapticsController;
+    tileSvgUrl: string | null;
+    autobetSelectedTileSvgUrl: string | null;
+    gemSvgUrl: string | null;
+    bombSvgUrl: string | null;
+    private _getTileInfo;
+    private calculateTileState;
+    render(): import('lit').TemplateResult<1>;
+}

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

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