@betorigami/games 0.7.4 → 0.7.6

package/dist/index.d.ts

@@ -1,6 +1,740 @@
-import { GameProviderWrapper } from './components/shared/GameProviderWrapper';
-import { DiceGame } from './components/dice/DiceGame';
-import { KenoGame } from './components/keno/KenoGame';
-import { LimboGame } from './components/limbo/LimboGame';
-import { MinesGame } from './components/mines/MinesGame';
-export { DiceGame, KenoGame, LimboGame, GameProviderWrapper, MinesGame };
+// Generated by dts-bundle-generator v9.5.1
+
+import { KenoRiskLevel } from '@betorigami/calculations';
+import { ContextProvider } from '@lit/context';
+import BigNumber from 'bignumber.js';
+import { CSSResult, LitElement, PropertyValues } from 'lit';
+
+declare enum Currency {
+	BTC = "BTC",
+	ETH = "ETH",
+	USDC = "USDC"
+}
+export type EventTypeRequiresDetail<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, unknown>> ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, never>> ? never : Partial<GlobalEventHandlersEventMap[T]["detail"]> extends GlobalEventHandlersEventMap[T]["detail"] ? never : T : never : never;
+export type EventTypeDoesNotRequireDetail<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, unknown>> ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, never>> ? T : Partial<GlobalEventHandlersEventMap[T]["detail"]> extends GlobalEventHandlersEventMap[T]["detail"] ? T : never : T : T;
+export type EventTypesWithRequiredDetail = {
+	[EventType in keyof GlobalEventHandlersEventMap as EventTypeRequiresDetail<EventType>]: true;
+};
+export type EventTypesWithoutRequiredDetail = {
+	[EventType in keyof GlobalEventHandlersEventMap as EventTypeDoesNotRequireDetail<EventType>]: true;
+};
+export type WithRequired<T, K extends keyof T> = T & {
+	[P in K]-?: T[P];
+};
+export type SlEventInit<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, unknown>> ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, never>> ? CustomEventInit<GlobalEventHandlersEventMap[T]["detail"]> : Partial<GlobalEventHandlersEventMap[T]["detail"]> extends GlobalEventHandlersEventMap[T]["detail"] ? CustomEventInit<GlobalEventHandlersEventMap[T]["detail"]> : WithRequired<CustomEventInit<GlobalEventHandlersEventMap[T]["detail"]>, "detail"> : CustomEventInit : CustomEventInit;
+export type GetCustomEventType<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<unknown> ? GlobalEventHandlersEventMap[T] : CustomEvent<unknown> : CustomEvent<unknown>;
+declare class OrigamiElement extends LitElement {
+	static componentStyles: CSSResult[];
+	/** Emits a custom event with more convenient defaults. */
+	emit<T extends string & keyof EventTypesWithoutRequiredDetail>(name: EventTypeDoesNotRequireDetail<T>, options?: SlEventInit<T> | undefined): GetCustomEventType<T>;
+	emit<T extends string & keyof EventTypesWithRequiredDetail>(name: EventTypeRequiresDetail<T>, options: SlEventInit<T>): GetCustomEventType<T>;
+}
+export interface GameHost {
+	gameData: gameContextType;
+	addController(controller: any): void;
+}
+declare class SoundController {
+	private host;
+	private muted;
+	private audioCache;
+	constructor(host: GameHost);
+	preload(file: string): void;
+	play(file: string): Promise<void>;
+	stop(): void;
+	pause(): void;
+}
+export type gameContextType = {
+	amount: string;
+	updateBalance: (newAmount: BigNumber) => void;
+	currency: Currency;
+	isCryptoMode: boolean;
+	isTheatreMode: boolean;
+	showFavorites: boolean;
+	balance: number;
+	baseUrl: string;
+	authToken: string;
+	gameStatsOpen: boolean;
+	hotkeysOpenEnabled: boolean;
+	volume: number;
+	instantBetEnabled: boolean;
+	updateHotkeysOpenEnabled: (enabled: boolean) => void;
+	updateVolume: (volume: number) => void;
+	updateInstantBetEnabled: (enabled: boolean) => void;
+	autobetNumberOfBets: number;
+	updateAutobetNumberOfBets: (numberOfBets: number) => void;
+	soundController?: SoundController;
+};
+declare const gameContext: {
+	__context__: gameContextType;
+};
+export declare class GameProviderWrapper extends OrigamiElement {
+	currency: Currency;
+	isTheatreMode: boolean;
+	showFavorites: boolean;
+	balance: number;
+	baseUrl: string;
+	authToken: string;
+	isCryptoMode: boolean;
+	gameStatsOpen: boolean;
+	private betAmount;
+	private autobetNumberOfBets;
+	private hotkeysOpenEnabled;
+	private volume;
+	private instantBetEnabled;
+	private _soundController;
+	firstUpdated(): void;
+	protected _gameProvider: ContextProvider<typeof gameContext>;
+	connectedCallback(): void;
+	updated(changedProperties: PropertyValues): void;
+	get gameData(): gameContextType;
+	private updateProviderValue;
+	updateHotkeysOpenEnabled(enabled: boolean): void;
+	updateVolume(volume: number): void;
+	updateInstantBetEnabled(enabled: boolean): void;
+	updateAutobetNumberOfBets(numberOfBets: number): void;
+	updateBalance(newAmount: BigNumber): void;
+	render(): import("lit-html").TemplateResult<1>;
+}
+declare enum MinesGameOutcome {
+	WIN = "WIN",
+	LOSS = "LOSS"
+}
+declare enum MinesFlowState {
+	NO_GAME_ACTIVE = "NO_GAME_ACTIVE",
+	GAME_IN_PROGRESS = "GAME_IN_PROGRESS",
+	VIEWING_RESULTS = "VIEWING_RESULTS"
+}
+export interface MinesState {
+	currency?: Currency;
+	selectedTiles: number[];
+	mineLocations: number[];
+	outcome: MinesGameOutcome | null;
+	minesCount: number;
+	numMinesRemaining: number;
+	numGemsFound: number;
+	numGemsRemaining: number;
+	state: MinesFlowState;
+	betAmount: BigNumber;
+}
+export type AfterBetEffect = "Reset" | "Increase";
+declare const defaultAutobetValues: {
+	onWinPercentage: string;
+	onLossPercentage: string;
+	stopOnProfit: string;
+	stopOnLoss: string;
+	onLossStrategy: AfterBetEffect;
+	onWinStrategy: AfterBetEffect;
+};
+export type AutobetValues = typeof defaultAutobetValues;
+export type BetMode = "Manual" | "Auto";
+declare enum OrigamiActionType {
+	START_BET = "START_BET",// bet started but not yet ended send to the /bet webhook
+	END_BET = "END_BET",// bet has been completed. Can be started and ended in 1 webhook or started in 1 and ended in another. send to the /bet webhook
+	ROLLBACK = "ROLLBACK",// send to the /rollback webhook
+	INTERMEDIATE_BET_ACTION = "INTERMEDIATE_BET_ACTION",// bet amount was increased without game ending, such as doubling down in blackjack
+	INTERMEDIATE_NON_BET_ACTION = "INTERMEDIATE_NON_BET_ACTION"
+}
+declare enum DiceDirection {
+	ABOVE = "ABOVE",
+	BELOW = "BELOW"
+}
+export interface DiceData {
+	resultValue: number;
+	userValue: number;
+	userDiceDirection: DiceDirection;
+}
+export interface Action {
+	id: string;
+	data: {
+		dice: DiceData;
+	};
+	type: OrigamiActionType;
+	actionIndex: number;
+	originalActionId: string | null;
+	betAmount: string;
+	payoutAmount: string;
+}
+export interface BetResult {
+	id: string;
+	tenantId: string;
+	userId: string;
+	usdRate: number;
+	gameId: string;
+	currency: Currency;
+	edge: number;
+	amount: string;
+	payout: string;
+	afterBalance: string;
+	maxPayoutReached: boolean;
+	multiplier: number;
+	clientSeed: string;
+	randomValue: string;
+	proof: string | null;
+	nonce: string | null;
+	completedAt: string | null;
+	actions: Action[];
+}
+export type DiceStartArgs = {
+	currency: Currency;
+	amount: string;
+	windowId?: string;
+	usdAmount?: number;
+	direction: DiceDirection;
+	selectedValue: number;
+};
+declare class DiceApi {
+	private authToken;
+	private baseUrl;
+	static totalDiceValue: number;
+	constructor(authToken: string, baseUrl: string);
+	startBet(data: DiceStartArgs): Promise<{
+		success: true;
+		data: BetResult;
+		error?: undefined;
+	} | {
+		success: false;
+		error: string;
+		data?: undefined;
+	}>;
+	static getMultiplier(selectedValue: number, diceDirection: DiceDirection): string;
+	static getWinChance(selectedValue: number, diceDirection: DiceDirection): string;
+	static getSelectedValueFromMultiplier(multiplier: number, diceDirection: DiceDirection): number;
+	static getSelectedValueFromWinChance(winChancePercentage: number, diceDirection: DiceDirection): number;
+	static getSelectedValueFromRollOver(selectedValue: number): number;
+}
+export interface KenoData {
+	/** The tiles selected by the player */
+	selectedTiles: number[];
+	/** The tiles containing gems (results) */
+	resultTiles: number[];
+	multiplier: number;
+	/** Risk level chosen by the player */
+	riskLevel: KenoRiskLevel;
+}
+interface Action$1 {
+	id: string;
+	data: {
+		keno: KenoData;
+	};
+	type: OrigamiActionType;
+	actionIndex: number;
+	originalActionId: string | null;
+	betAmount: string;
+	payoutAmount: string;
+}
+interface BetResult$1 {
+	id: string;
+	tenantId: string;
+	userId: string;
+	usdRate: number;
+	gameId: string;
+	currency: Currency;
+	edge: number;
+	amount: string;
+	payout: string;
+	afterBalance: string;
+	maxPayoutReached: boolean;
+	multiplier: number;
+	clientSeed: string;
+	randomValue: string;
+	proof: string | null;
+	nonce: string | null;
+	completedAt: string | null;
+	actions: Action$1[];
+}
+export type KenoStartArgs = {
+	currency: Currency;
+	amount: string;
+	windowId?: string;
+	usdAmount?: number;
+	riskLevel: KenoRiskLevel;
+	selectedTiles: number[];
+};
+declare class KenoApi {
+	private authToken;
+	private baseUrl;
+	constructor(authToken: string, baseUrl: string);
+	startBet(data: KenoStartArgs): Promise<{
+		success: true;
+		data: BetResult$1;
+		error?: undefined;
+	} | {
+		success: false;
+		error: string;
+		data?: undefined;
+	}>;
+}
+export interface LimboData {
+	targetMultiplier: number;
+	resultMultiplier: number;
+}
+interface Action$2 {
+	id: string;
+	data: {
+		limbo: LimboData;
+	};
+	type: OrigamiActionType;
+	actionIndex: number;
+	originalActionId: string | null;
+	betAmount: string;
+	payoutAmount: string;
+}
+interface BetResult$2 {
+	id: string;
+	tenantId: string;
+	userId: string;
+	usdRate: number;
+	gameId: string;
+	currency: Currency;
+	edge: number;
+	amount: string;
+	payout: string;
+	afterBalance: string;
+	maxPayoutReached: boolean;
+	multiplier: number;
+	clientSeed: string;
+	randomValue: string;
+	proof: string | null;
+	nonce: string | null;
+	completedAt: string | null;
+	actions: Action$2[];
+}
+export type LimboStartArgs = {
+	currency: Currency;
+	amount: string;
+	windowId?: string;
+	usdAmount?: number;
+	targetMultiplier: number;
+};
+declare class LimboApi {
+	private authToken;
+	private baseUrl;
+	constructor(authToken: string, baseUrl: string);
+	startBet: (data: LimboStartArgs) => Promise<{
+		success: true;
+		data: BetResult$2;
+		error?: undefined;
+	} | {
+		success: false;
+		error: string;
+		data?: undefined;
+	}>;
+	static calculateMultiplier(winChance: number): string;
+	static calculateWinChance(targetMultiplier: number): string;
+	static calculateProfitOnWin(amount: string, targetMultiplier: number): string;
+}
+export interface MinesData {
+	minesResult: number[];
+	minesCount: number;
+	winMultiplier: string;
+	selected: number[];
+}
+export interface MinesAction {
+	id: string;
+	data: {
+		mines: MinesData;
+	};
+	type: OrigamiActionType;
+	actionIndex: number;
+	originalActionId: string | null;
+	betAmount: string;
+	payoutAmount: string;
+}
+interface BetResult$3 {
+	id: string;
+	tenantId: string;
+	userId: string;
+	usdRate: number;
+	gameId: string;
+	currency: Currency;
+	edge: number;
+	amount: string;
+	payout: string;
+	afterBalance: string;
+	maxPayoutReached: boolean;
+	multiplier: number;
+	clientSeed: string;
+	randomValue: string;
+	proof: string | null;
+	nonce: string | null;
+	completedAt: string | null;
+	actions: MinesAction[];
+}
+export type MinesManualStartArgs = {
+	currency: Currency;
+	amount: string;
+	windowId?: string;
+	usdAmount?: number;
+	minesCount: number;
+};
+export type MinesNextArgs = {
+	betId: string;
+	selected: number[];
+};
+export type MinesAutoArgs = {
+	currency: Currency;
+	amount: string;
+	windowId?: string;
+	usdAmount?: number;
+	minesCount?: number;
+	selected: number[];
+};
+declare class MinesApi {
+	private authToken;
+	private baseUrl;
+	constructor(authToken: string, baseUrl: string);
+	startManualBet(data: MinesManualStartArgs): Promise<{
+		success: true;
+		data: BetResult$3;
+		error?: undefined;
+	} | {
+		success: false;
+		error: string;
+		data?: undefined;
+	}>;
+	getActiveBet(): Promise<{
+		success: false;
+		error: string;
+		data?: undefined;
+	} | {
+		success: true;
+		data: BetResult$3;
+		error?: undefined;
+	}>;
+	selectTile(minesNextArgs: MinesNextArgs): Promise<{
+		success: true;
+		data: BetResult$3;
+		error?: undefined;
+	} | {
+		success: false;
+		error: string;
+		data?: undefined;
+	}>;
+	cashout(): Promise<{
+		success: true;
+		data: BetResult$3;
+		error?: undefined;
+	} | {
+		success: false;
+		error: string;
+		data?: undefined;
+	}>;
+	autobetPlay(data: MinesAutoArgs): Promise<{
+		success: true;
+		data: BetResult$3;
+		error?: undefined;
+	} | {
+		success: false;
+		error: string;
+		data?: undefined;
+	}>;
+	static getInitialState: () => MinesState;
+	static deriveSelectedTiles: (actions?: Array<MinesAction> | null) => number[];
+	static deriveMineLocations: (actions?: Array<MinesAction> | null) => number[];
+	static getMinesBetInfo: (actions: MinesAction[]) => {
+		selected: number[];
+		mines: number[];
+	};
+	static deriveOutcome: (bet?: BetResult$3) => MinesGameOutcome | null;
+	static deriveAutoOutcome: (bet?: BetResult$3 | null) => MinesGameOutcome | null;
+	static calculateMinesMultiplier: (gemsFound: number, mines: number) => BigNumber;
+	static getState: (bet: BetResult$3) => MinesState;
+}
+export type AutobetToggleEvent = CustomEvent<AutobetValues & {
+	numberOfBets: string;
+}>;
+export type SliderChangeEvent = CustomEvent<{
+	value: number;
+}>;
+export type DiceMultiplierChangeEvent = CustomEvent<{
+	multiplier: string;
+}>;
+export type DiceWinChanceChangeEvent = CustomEvent<{
+	winChance: string;
+}>;
+export type LimboMultiplierChangeEvent = CustomEvent<{
+	multiplier: string;
+}>;
+export type LimboWinChanceChangeEvent = CustomEvent<{
+	winChance: string;
+}>;
+export type LimboMultiplierAnimationEndEvent = CustomEvent<{
+	resultMultiplier: number;
+	isWin: boolean;
+	betId: string;
+}>;
+export type KenoRiskChangeEvent = CustomEvent<{
+	value: KenoRiskLevel;
+}>;
+export type KenoTileClickEvent = CustomEvent<{
+	tile: number;
+}>;
+export interface AutobetSettings {
+	onWinStrategy: AfterBetEffect;
+	onLossStrategy: AfterBetEffect;
+	onWinPercentage: string | number;
+	onLossPercentage: string | number;
+	stopOnLoss: string;
+	stopOnProfit: string;
+	numberOfBets?: number;
+	autobetBets?: number;
+}
+export interface GameBetResult {
+	pnl: BigNumber;
+	gameOutcome: "Win" | "Loss" | "Draw";
+	hasError: boolean;
+	errorMessage?: string;
+}
+declare abstract class GameComponent extends OrigamiElement {
+	protected manualOrAuto: BetMode;
+	protected hasPendingBet: boolean;
+	protected autobetInProgress: boolean;
+	protected autobetStopping: boolean;
+	static soundsToPreload: string[];
+	static styles: import("lit").CSSResult[];
+	private gameConsumer;
+	get gameData(): gameContextType;
+	/**
+	 * Common getter for when the toggle between Manual/Auto should be disabled
+	 * Override in child classes if additional conditions are needed
+	 */
+	get isToggleDisabled(): boolean;
+	/**
+	 * Common getter for when inputs and controls should be disabled
+	 * Override in child classes to add game-specific conditions
+	 */
+	get areInputsDisabled(): boolean;
+	/**
+	 * Returns appropriate delay based on instant bet setting
+	 * Keeps minimal delay for animations while making betting feel instant
+	 */
+	protected getDelay(normalDelay: number): number;
+	/**
+	 * Forces UI update and waits for next frame - useful in instant mode
+	 */
+	protected forceUIUpdate(): Promise<void>;
+	/**
+	 * Executes an operation either instantly or with animation based on instant bet setting
+	 * @param instantOperation - Function to execute in instant mode
+	 * @param animatedOperation - Function to execute in normal mode
+	 */
+	protected executeInstantOrAnimated<T>(instantOperation: () => Promise<T> | T, animatedOperation: () => Promise<T> | T): Promise<T>;
+	/**
+	 * Ensures minimum display time for autobet results in instant mode
+	 * @param hasWin - Whether the round was a win (longer display time)
+	 * @param winDisplayTime - Display time for wins (default 500ms)
+	 * @param lossDisplayTime - Display time for losses (default 500ms)
+	 */
+	protected ensureMinimumDisplayTime(hasWin?: boolean, winDisplayTime?: number, lossDisplayTime?: number): Promise<void>;
+	firstUpdated(): void;
+	toggleAutobet(event: AutobetToggleEvent): Promise<void>;
+	protected abstract executeAutobet(_autobetSettings: AutobetSettings, _currentBetAmount: string): Promise<GameBetResult>;
+	protected adjustBetAmount(autobetSettings: AutobetSettings, gameOutcome: "Win" | "Loss" | "Draw", originalBetAmount: string, currentBetAmount: string): string;
+	protected isPnLWithinLimits(autobetSettings: AutobetSettings, totalPnL: BigNumber): boolean;
+}
+declare class MockDiceApi {
+	private static getRandomValueInRange;
+	startBet(data: DiceStartArgs): Promise<{
+		success: true;
+		data: BetResult;
+	}>;
+}
+export declare class DiceGame extends GameComponent {
+	static soundsToPreload: string[];
+	private diceDirection;
+	private selectedValue;
+	private isManualPlaying;
+	private showDice;
+	private isWin;
+	private resultValue;
+	private history;
+	private _diceManualEl?;
+	private _diceAutoEl?;
+	get isToggleDisabled(): boolean;
+	get areInputsDisabled(): boolean;
+	firstUpdated(): void;
+	private isSpacebarDisabled;
+	private handleSpacebar;
+	diceRollOverToggle: () => void;
+	constructor();
+	private decreaseSlider;
+	private increaseSlider;
+	get diceApi(): DiceApi | MockDiceApi;
+	dicePlay(): Promise<void>;
+	private handleBetExecution;
+	addToHistory(multiplier: number, won: boolean, id: string): void;
+	protected executeAutobet(_autobetSettings: AutobetSettings, currentBetAmount: string): Promise<GameBetResult>;
+	sliderInputChange: (e: SliderChangeEvent) => void;
+	diceMultiplierChange: (e: DiceMultiplierChangeEvent) => void;
+	diceWinChanceChange: (e: DiceWinChanceChangeEvent) => void;
+	render(): import("lit-html").TemplateResult<1>;
+}
+declare class MockKenoApi {
+	private static generateRandomTiles;
+	private static calculateMultiplier;
+	startBet: (data: KenoStartArgs) => Promise<{
+		success: true;
+		data: BetResult$1;
+	}>;
+}
+export declare class KenoGame extends GameComponent {
+	static soundsToPreload: string[];
+	private isManualPlaying;
+	private history;
+	private selectedTiles;
+	private resultTiles;
+	gameWinPopupShowing: boolean;
+	private gameOver;
+	private payout;
+	private kenoRisk;
+	private autoselectRunning;
+	private multiplier;
+	private hadTilesBeforeAutopick;
+	private betId;
+	private _kenoManualEl?;
+	private _kenoAutoEl?;
+	get isToggleDisabled(): boolean;
+	get areInputsDisabled(): boolean;
+	get kenoApi(): KenoApi | MockKenoApi;
+	kenoPlay(): Promise<void>;
+	private handleBetExecution;
+	addToHistory(multiplier: number, won: boolean): void;
+	protected executeAutobet(_autobetSettings: AutobetSettings, currentBetAmount: string): Promise<GameBetResult>;
+	handleTileClick: (e: KenoTileClickEvent) => void;
+	handleRiskChange: (e: KenoRiskChangeEvent) => void;
+	autoPick: () => Promise<void>;
+	clearTable: () => void;
+	newGame: () => void;
+	render(): import("lit-html").TemplateResult<1>;
+	private getButton;
+	private isButtonDisabled;
+	private handleSpacebar;
+	private handleAutoPick;
+	private handleClearTable;
+	constructor();
+}
+declare class MockLimboApi {
+	private static getRandomMultiplier;
+	startBet: (data: LimboStartArgs) => Promise<{
+		success: true;
+		data: BetResult$2;
+	}>;
+}
+export declare class LimboGame extends GameComponent {
+	static soundsToPreload: string[];
+	private targetMultiplier;
+	private resultMultiplier;
+	private isManualPlaying;
+	private isWin;
+	private history;
+	private betTargetMultiplier;
+	private betId;
+	private _limboManualEl?;
+	private _limboAutoEl?;
+	get isToggleDisabled(): boolean;
+	get areInputsDisabled(): boolean;
+	get limboApi(): LimboApi | MockLimboApi;
+	firstUpdated(): void;
+	limboPlay(): Promise<void>;
+	private handleBetExecution;
+	private isSpacebarDisabled;
+	private handleSpacebar;
+	constructor();
+	protected executeAutobet(_autobetSettings: AutobetSettings, currentBetAmount: string): Promise<GameBetResult>;
+	multiplierChange: (e: LimboMultiplierChangeEvent) => void;
+	calculateProfitOnWin(): string;
+	winChanceChange: (e: LimboWinChanceChangeEvent) => void;
+	multiplierAnimationEnd: (e: LimboMultiplierAnimationEndEvent) => void;
+	render(): import("lit-html").TemplateResult<1>;
+}
+export interface MockMinesSettings {
+	shouldWin: boolean;
+	minePositions?: number[];
+}
+declare class MockMinesApi {
+	private static mockSettings;
+	private static activeBet;
+	private static minePositions;
+	static setMockSettings(settings: MockMinesSettings): void;
+	private static getRandomValueInRange;
+	private static generateMinePositions;
+	private static addAction;
+	private static updateBetResult;
+	startManualBet(data: MinesManualStartArgs): Promise<{
+		success: true;
+		data: BetResult$3;
+	}>;
+	getActiveBet(): Promise<{
+		success: false;
+		error: string;
+		data?: undefined;
+	} | {
+		success: true;
+		data: BetResult$3;
+		error?: undefined;
+	}>;
+	selectTile(data: MinesNextArgs): Promise<{
+		success: false;
+		error: string;
+		data?: undefined;
+	} | {
+		success: true;
+		data: BetResult$3;
+		error?: undefined;
+	}>;
+	cashout(): Promise<{
+		success: false;
+		error: string;
+		data?: undefined;
+	} | {
+		success: true;
+		data: BetResult$3;
+		error?: undefined;
+	}>;
+	autobetPlay(data: MinesAutoArgs): Promise<{
+		success: true;
+		data: BetResult$3;
+	}>;
+}
+export declare class MinesGame extends GameComponent {
+	static soundsToPreload: string[];
+	private minesCount;
+	private autobetSelectedTiles;
+	private minesData;
+	private isLoading;
+	private isSelectingRandomTile;
+	private history;
+	private isCheckingForSession;
+	private loadingTiles;
+	private _minesManualEl?;
+	private _minesAutoEl?;
+	private _playSound;
+	private authTokenWatcher;
+	get isToggleDisabled(): boolean;
+	get areInputsDisabled(): boolean;
+	get isGameActive(): boolean;
+	get minesApi(): MinesApi | MockMinesApi;
+	addToHistory(multiplier: number, won: boolean, id: string): void;
+	getMinesActiveBet(): Promise<void>;
+	firstUpdated(): Promise<void>;
+	protected updated(changedProperties: Map<string | number | symbol, unknown>): void;
+	get getMinesState(): MinesState | null;
+	protected executeAutobet(_autobetSettings: AutobetSettings, currentBetAmount: string): Promise<GameBetResult>;
+	toggleAutobet(event: AutobetToggleEvent): Promise<void>;
+	private 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 pickRandomTile;
+	private waitForAnimationsComplete;
+	constructor();
+	render(): import("lit-html").TemplateResult<1>;
+}
+
+export {};