@betorigami/games 1.22.9 → 2.0.0

package/dist/index.d.ts

@@ -827,6 +827,7 @@ export declare const translations: {
 			dice: {
 				multiplierRange: string;
 				winChanceRange: string;
+				rollValueRange: string;
 			};
 			roulette: {
 				oppositeBet: string;
@@ -5684,393 +5685,117 @@ declare class HapticsController {
 	bombImpact(): void;
 	winCelebration(): void;
 }
-declare enum WheelRiskLevel {
-	LOW_RISK = "LOW_RISK",
-	MEDIUM_RISK = "MEDIUM_RISK",
-	HIGH_RISK = "HIGH_RISK"
-}
-declare enum WheelSegments {
-	TEN = 10,
-	TWENTY = 20,
-	THIRTY = 30,
-	FORTY = 40,
-	FIFTY = 50
-}
-declare enum PlinkoRiskLevel {
-	LOW_RISK = "LOW_RISK",
-	MEDIUM_RISK = "MEDIUM_RISK",
-	HIGH_RISK = "HIGH_RISK"
-}
-declare const plinkoRowCountOptions: readonly [
-	8,
-	9,
-	10,
-	11,
-	12,
-	13,
-	14,
-	15,
-	16
-];
-export type PlinkoRowCount = (typeof plinkoRowCountOptions)[number];
-declare enum DiceDirection {
-	ABOVE = "ABOVE",
-	BELOW = "BELOW"
-}
-declare enum KenoRiskLevel {
-	CLASSIC = "CLASSIC",
-	LOW_RISK = "LOW_RISK",
-	MEDIUM_RISK = "MEDIUM_RISK",
-	HIGH_RISK = "HIGH_RISK"
+export interface HistoryItem {
+	id: string;
+	fullId: string;
+	timestamp: string;
+	currency: string;
+	bet: number;
+	win: number;
 }
-declare const VALID_KENO_EDGES: readonly [
-	1,
-	2,
-	3,
-	4,
-	8
-];
-export type KenoEdge = (typeof VALID_KENO_EDGES)[number];
-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"
+interface GameHost$1 {
+	gameData: gameContextType;
+	addController(controller: any): void;
 }
-export type Bounds = {
-	lower: number;
-	upper: number;
+export type NewHistoryItem = {
+	readonly id: string;
+	readonly currency: Currency;
+	readonly amount: string | number;
+	readonly payout: string | number | null;
 };
-declare enum RollType {
-	ROLL_BETWEEN = "ROLL_BETWEEN",
-	ROLL_OUTSIDE = "ROLL_OUTSIDE",
-	ROLL_BETWEEN_TWO = "ROLL_BETWEEN_TWO"
+declare class HistoryController extends EventTarget {
+	private host;
+	private _historyData;
+	private _hasData;
+	private _isInitialized;
+	private _hasNextPage;
+	private _initialLoadSize;
+	private _hasLoadedMore;
+	private _clientSeed;
+	private _hasLoadedClientSeed;
+	constructor(host: GameHost$1);
+	get historyData(): HistoryItem[];
+	get hasData(): boolean | null;
+	get isInitialized(): boolean;
+	get hasNextPage(): boolean;
+	get clientSeed(): string | null;
+	get hasLoadedClientSeed(): boolean;
+	private notifyDataChanged;
+	private notifyClientSeedChanged;
+	private preloadHistory;
+	fetchHistory(beforeId?: string, numberToFetch?: number): Promise<{
+		historyData: HistoryItem[];
+		hasNextPage: boolean;
+	}>;
+	refreshHistory(preserveLoadedMore?: boolean): Promise<void>;
+	loadMore(): Promise<{
+		historyData: HistoryItem[];
+		hasNextPage: boolean;
+	}>;
+	addNewBet(betResult: NewHistoryItem): void;
+	loadClientSeed(): Promise<void>;
+	updateClientSeed(newSeed: string): void;
 }
-export type RollBetween = {
-	mode: RollType.ROLL_BETWEEN;
-	bounds: Bounds;
-};
-export type RollOutside = {
-	mode: RollType.ROLL_OUTSIDE;
-	bounds: Bounds;
-};
-export type RollBetweenTwo = {
-	mode: RollType.ROLL_BETWEEN_TWO;
-	firstBounds: Bounds;
-	secondBounds: Bounds;
-};
-export type AdvancedDiceInputs = RollBetween | RollOutside | RollBetweenTwo;
-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 AutobetEventPayload = AutobetValues & {
-	numberOfBets: string;
-};
-export type DiceStartAction = {
-	direction: DiceDirection;
-	selectedValue: number;
-};
-export type KenoStartAction = {
-	riskLevel: KenoRiskLevel;
-	selectedNumbers: number[];
-};
-export type EndAction = {
-	result: number[];
-};
-export type LimboStartAction = {
-	targetMultiplier: number;
-};
-export type LimboEndAction = {
-	result: number[];
-	randomMultiplier: string;
+export type SoundWaveform = "sine" | "triangle" | "sawtooth" | "square";
+export type SoundFilterType = "bandpass" | "lowpass" | "highpass";
+export type ToneGainDef = {
+	envelope: "peak-decay";
+	peak: number;
+	decayTime: number;
+} | {
+	envelope: "attack-decay";
+	attackTime: number;
+	peak: number;
+	decayTime: number;
+} | {
+	envelope: "delayed-attack-decay";
+	holdTime: number;
+	attackEndTime: number;
+	peak: number;
+	decayTime: number;
 };
-export type MinesStartAction = {
-	minesCount: number;
-	selectedTiles: number[];
-	hasCashedOut: boolean;
+export type NoiseLayerDef = {
+	kind: "noise";
+	duration: number;
+	decay: number;
+	filterType: SoundFilterType;
+	filterFreq: number;
+	filterQ: number;
+	gain: number;
+	randomization: number;
+	filterFreqEnd?: number;
+	filterFreqRampTime?: number;
 };
-export interface DiamondsStartAction {
-}
-export interface WheelStartAction {
-	riskLevel: WheelRiskLevel;
-	segments: WheelSegments;
-}
-export interface PlinkoStartAction {
-	riskLevel: PlinkoRiskLevel;
-	numberOfRows: PlinkoRowCount;
-}
-export type AdvancedDiceStartAction = AdvancedDiceInputs;
-export type BaccaratEndAction = BaccaratGameOutputs & {
-	result: number[];
+export type ToneLayerDef = {
+	kind: "tone";
+	waveform: SoundWaveform;
+	frequency: number;
+	frequencyEnd?: number;
+	frequencyRampTime?: number;
+	duration: number;
+	gain: ToneGainDef;
+	startOffset?: number;
 };
-export interface RouletteStraightBet {
-	amount: string;
-	value: number;
-}
-export interface RouletteSplitBet {
-	amount: string;
-	values: readonly [
-		number,
-		number
-	];
-}
-export interface RouletteStreetBet {
-	amount: string;
-	values: readonly [
-		number,
-		number,
-		number
-	];
-}
-export interface RouletteCornerBet {
-	amount: string;
-	values: readonly [
-		number,
-		number,
-		number,
-		number
-	];
+export type SoundLayerDef = NoiseLayerDef | ToneLayerDef;
+export interface ResolvedSound {
+	readonly layers: readonly SoundLayerDef[];
+	readonly gainScale: number;
 }
-export interface RouletteDoubleStreetBet {
-	amount: string;
-	values: readonly [
-		number,
-		number,
-		number,
-		number,
-		number,
-		number
-	];
+interface GameHost$2 {
+	addController(controller: unknown): void;
 }
-export interface RouletteParityBet {
-	amount: string;
-	parity: Parity;
-}
-export interface RouletteColorBet {
-	amount: string;
-	color: Color;
-}
-export interface RouletteHalfBet {
-	amount: string;
-	half: Half;
-}
-export interface RouletteColumnBet {
-	amount: string;
-	column: Column;
-}
-export interface RouletteDozenBet {
-	amount: string;
-	dozen: Dozen;
-}
-export interface RouletteBasketBet {
-	amount: string;
-}
-export interface EuropeanRouletteInputs {
-	straightBets: RouletteStraightBet[];
-	splitBets: RouletteSplitBet[];
-	streetBets: RouletteStreetBet[];
-	cornerBets: RouletteCornerBet[];
-	doubleStreetBets: RouletteDoubleStreetBet[];
-	parityBets: RouletteParityBet[];
-	colorBets: RouletteColorBet[];
-	halfBets: RouletteHalfBet[];
-	columnBets: RouletteColumnBet[];
-	dozenBets: RouletteDozenBet[];
-}
-export interface AmericanRouletteInputs extends EuropeanRouletteInputs {
-	basketBets: RouletteBasketBet[];
-}
-export type RouletteStartAction = {
-	type: RouletteType.EUROPEAN;
-	inputs: EuropeanRouletteInputs;
-} | {
-	type: RouletteType.AMERICAN;
-	inputs: AmericanRouletteInputs;
-};
-export interface RouletteBetOutcomes {
-	winningBets: EuropeanRouletteInputs;
-	losingBets: EuropeanRouletteInputs;
-}
-export interface RouletteEndAction {
-	type: "european" | "american";
-	betOutcomes: RouletteBetOutcomes;
-	result: number[];
-}
-export interface Action {
-	id: string;
-	data: {
-		DICE?: DiceStartAction | EndAction;
-		KENO?: KenoStartAction | EndAction;
-		LIMBO?: LimboStartAction | LimboEndAction;
-		MINES?: MinesStartAction | EndAction;
-		DIAMONDS?: DiamondsStartAction | EndAction;
-		WHEEL?: WheelStartAction | EndAction;
-		PLINKO?: PlinkoStartAction | EndAction;
-		ADVANCED_DICE?: AdvancedDiceStartAction | EndAction;
-		ROULETTE?: RouletteStartAction | RouletteEndAction;
-		BACCARAT?: BaccaratGameInputs | BaccaratEndAction;
-	};
-	betAmount: string | null;
-	payoutAmount: string | null;
-	actionIndex: number;
-	type: OrigamiActionType;
-}
-export interface BetResult {
-	id: string;
-	nonce: number;
-	amount: string;
-	payout: string | null;
-	currency: Currency;
-	userId: string;
-	gameId: string;
-	multiplier: string | null;
-	tenantId: string;
-	clientSeed: string;
-	randomValue: string | null;
-	proof: string | null;
-	afterBalance: string | null;
-	tenantUserId: string;
-	betActions: Array<Action>;
-}
-export type StartBetResponse = {
-	success: true;
-	data: BetResult;
-} | {
-	success: false;
-	error: string;
-};
-export type AutobetApiSettings = {
-	onWinStrategy: AfterBetEffect;
-	onLossStrategy: AfterBetEffect;
-	onWinPercentage: string;
-	onLossPercentage: string;
-	stopOnLoss: string;
-	stopOnProfit: string;
-	numberOfBets: number;
-	autobetId: string;
-	betIndex: number;
-	pnlSinceStart: string;
-};
-export interface BaseStartArgs {
-	currency: Currency;
-	amount: string;
-	meta?: {
-		autobetSettings?: AutobetApiSettings;
-	};
-}
-export interface HistoryItem {
-	id: string;
-	fullId: string;
-	timestamp: string;
-	currency: string;
-	bet: number;
-	win: number;
-}
-interface GameHost$1 {
-	gameData: gameContextType;
-	addController(controller: any): void;
-}
-declare class HistoryController extends EventTarget {
-	private host;
-	private _historyData;
-	private _hasData;
-	private _isInitialized;
-	private _hasNextPage;
-	private _initialLoadSize;
-	private _hasLoadedMore;
-	private _clientSeed;
-	private _hasLoadedClientSeed;
-	constructor(host: GameHost$1);
-	get historyData(): HistoryItem[];
-	get hasData(): boolean | null;
-	get isInitialized(): boolean;
-	get hasNextPage(): boolean;
-	get clientSeed(): string | null;
-	get hasLoadedClientSeed(): boolean;
-	private notifyDataChanged;
-	private notifyClientSeedChanged;
-	private preloadHistory;
-	fetchHistory(beforeId?: string, numberToFetch?: number): Promise<{
-		historyData: HistoryItem[];
-		hasNextPage: boolean;
-	}>;
-	refreshHistory(preserveLoadedMore?: boolean): Promise<void>;
-	loadMore(): Promise<{
-		historyData: HistoryItem[];
-		hasNextPage: boolean;
-	}>;
-	addNewBet(betResult: BetResult): void;
-	loadClientSeed(): Promise<void>;
-	updateClientSeed(newSeed: string): void;
-}
-export type SoundWaveform = "sine" | "triangle" | "sawtooth" | "square";
-export type SoundFilterType = "bandpass" | "lowpass" | "highpass";
-export type ToneGainDef = {
-	envelope: "peak-decay";
-	peak: number;
-	decayTime: number;
-} | {
-	envelope: "attack-decay";
-	attackTime: number;
-	peak: number;
-	decayTime: number;
-} | {
-	envelope: "delayed-attack-decay";
-	holdTime: number;
-	attackEndTime: number;
-	peak: number;
-	decayTime: number;
-};
-export type NoiseLayerDef = {
-	kind: "noise";
-	duration: number;
-	decay: number;
-	filterType: SoundFilterType;
-	filterFreq: number;
-	filterQ: number;
-	gain: number;
-	randomization: number;
-	filterFreqEnd?: number;
-	filterFreqRampTime?: number;
-};
-export type ToneLayerDef = {
-	kind: "tone";
-	waveform: SoundWaveform;
-	frequency: number;
-	frequencyEnd?: number;
-	frequencyRampTime?: number;
-	duration: number;
-	gain: ToneGainDef;
-	startOffset?: number;
-};
-export type SoundLayerDef = NoiseLayerDef | ToneLayerDef;
-export interface ResolvedSound {
-	readonly layers: readonly SoundLayerDef[];
-	readonly gainScale: number;
-}
-interface GameHost$2 {
-	addController(controller: unknown): void;
-}
-declare class SoundEffectsController {
-	private destroyed;
-	private audioCtx;
-	private volume;
-	constructor(host: GameHost$2);
-	setVolume(normalizedVolume: number): void;
-	destroy(): void;
-	play(sound: ResolvedSound): void;
-	private ensureAudio;
-	private renderLayers;
-	private renderNoiseLayer;
-	private renderToneLayer;
+declare class SoundEffectsController {
+	private destroyed;
+	private audioCtx;
+	private volume;
+	constructor(host: GameHost$2);
+	setVolume(normalizedVolume: number): void;
+	destroy(): void;
+	play(sound: ResolvedSound): void;
+	private ensureAudio;
+	private renderLayers;
+	private renderNoiseLayer;
+	private renderToneLayer;
 }
 export type gameContextType = {
 	betAmount: string;
@@ -6266,141 +5991,387 @@ export declare class BetDetailsComponent extends OrigamiElement {
 	private handleShare;
 	private fetchBetDetails;
 }
+declare enum DiceDirection {
+	ABOVE = "ABOVE",
+	BELOW = "BELOW"
+}
 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: Big$1;
+export interface MinesState {
+	selectedTiles: number[];
+	mineLocations: number[];
+	outcome: MinesGameOutcome | null;
+	minesCount: number;
+	numMinesRemaining: number;
+	numGemsFound: number;
+	numGemsRemaining: number;
+	state: MinesFlowState;
+	betAmount: Big$1;
+}
+declare enum WheelRiskLevel {
+	LOW_RISK = "LOW_RISK",
+	MEDIUM_RISK = "MEDIUM_RISK",
+	HIGH_RISK = "HIGH_RISK"
+}
+declare enum WheelSegments {
+	TEN = 10,
+	TWENTY = 20,
+	THIRTY = 30,
+	FORTY = 40,
+	FIFTY = 50
+}
+export type Bounds = {
+	lower: number;
+	upper: number;
+};
+declare enum RollType {
+	ROLL_BETWEEN = "ROLL_BETWEEN",
+	ROLL_OUTSIDE = "ROLL_OUTSIDE",
+	ROLL_BETWEEN_TWO = "ROLL_BETWEEN_TWO"
+}
+export type RollBetween = {
+	mode: RollType.ROLL_BETWEEN;
+	bounds: Bounds;
+};
+export type RollOutside = {
+	mode: RollType.ROLL_OUTSIDE;
+	bounds: Bounds;
+};
+export type RollBetweenTwo = {
+	mode: RollType.ROLL_BETWEEN_TWO;
+	firstBounds: Bounds;
+	secondBounds: Bounds;
+};
+export type AdvancedDiceInputs = RollBetween | RollOutside | RollBetweenTwo;
+declare enum PlinkoRiskLevel {
+	LOW_RISK = "LOW_RISK",
+	MEDIUM_RISK = "MEDIUM_RISK",
+	HIGH_RISK = "HIGH_RISK"
+}
+declare const plinkoRowCountOptions: readonly [
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	16
+];
+export type PlinkoRowCount = (typeof plinkoRowCountOptions)[number];
+export type BetMode = "Manual" | "Auto";
+export type AfterBetEffect = "Reset" | "Increase";
+export type AutobetValues = {
+	onWinPercentage: string;
+	onLossPercentage: string;
+	stopOnProfit: string;
+	stopOnLoss: string;
+	onLossStrategy: AfterBetEffect;
+	onWinStrategy: AfterBetEffect;
+};
+export type AutobetEventPayload = AutobetValues & {
+	numberOfBets: string;
+};
+declare enum KenoRiskLevel {
+	CLASSIC = "CLASSIC",
+	LOW_RISK = "LOW_RISK",
+	MEDIUM_RISK = "MEDIUM_RISK",
+	HIGH_RISK = "HIGH_RISK"
+}
+declare const VALID_KENO_EDGES: readonly [
+	1,
+	2,
+	3,
+	4,
+	8
+];
+export type KenoEdge = (typeof VALID_KENO_EDGES)[number];
+export type AutobetToggleEvent = CustomEvent<AutobetEventPayload>;
+export type LimboMultiplierChangeEvent = CustomEvent<{
+	multiplier: string;
+}>;
+export type LimboMultiplierAnimationEndEvent = CustomEvent<{
+	resultMultiplier: number;
+	isWin: boolean;
+	betId: string;
+}>;
+export type KenoRiskChangeEvent = CustomEvent<{
+	value: KenoRiskLevel;
+}>;
+export type KenoTileClickEvent = CustomEvent<{
+	tile: number;
+}>;
+export type AutobetSettingsWithId = AutobetEventPayload & {
+	autobetId: string;
+	betIndex: number;
+	pnlSinceStart: string;
+};
+export interface GameBetResult {
+	pnl: Big$1;
+	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 styles: import("lit").CSSResult[];
+	protected onBetAmountChange: (_oldBetAmount: string, _newBetAmount: string) => void;
+	private gameConsumer;
+	get gameData(): gameContextType;
+	get isDemoMode(): boolean;
+	get isToggleDisabled(): boolean;
+	get areInputsDisabled(): boolean;
+	protected getDelay(normalDelay: number): number;
+	protected getAutobetDelay(): number;
+	protected forceUIUpdate(): Promise<void>;
+	protected executeInstantOrAnimated<T>(instantOperation: () => Promise<T> | T, animatedOperation: () => Promise<T> | T): Promise<T>;
+	/**
+	 * @deprecated Use sleep instead
+	 */
+	protected ensureMinimumDisplayTime(hasWin?: boolean, winDisplayTime?: number, lossDisplayTime?: number): Promise<void>;
+	disconnectedCallback(): void;
+	toggleAutobet(event: AutobetToggleEvent): Promise<void>;
+	protected abstract executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
+	protected adjustBetAmount(autobetSettings: AutobetSettingsWithId, gameOutcome: "Win" | "Loss" | "Draw", originalBetAmount: string, currentBetAmount: string): string;
+	protected isPnLWithinLimits(autobetSettings: AutobetSettingsWithId, totalPnL: Big$1): boolean;
+	protected updateHistoryWithBet(betResult: NewHistoryItem): void;
+	protected showError(message: string): void;
+	protected playWinFeedback(): void;
+}
+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"
+}
+export type DiceStartAction = {
+	direction: DiceDirection;
+	selectedValue: number;
+};
+export type KenoStartAction = {
+	riskLevel: KenoRiskLevel;
+	selectedNumbers: number[];
+};
+export type EndAction = {
+	result: number[];
+};
+export type LimboStartAction = {
+	targetMultiplier: number;
+};
+export type LimboEndAction = {
+	result: number[];
+	randomMultiplier: string;
+};
+export type MinesStartAction = {
+	minesCount: number;
+	selectedTiles: number[];
+	hasCashedOut: boolean;
+};
+export interface DiamondsStartAction {
+}
+export interface WheelStartAction {
+	riskLevel: WheelRiskLevel;
+	segments: WheelSegments;
+}
+export interface PlinkoStartAction {
+	riskLevel: PlinkoRiskLevel;
+	numberOfRows: PlinkoRowCount;
+}
+export type AdvancedDiceStartAction = AdvancedDiceInputs;
+export type BaccaratEndAction = BaccaratGameOutputs & {
+	result: number[];
+};
+export interface RouletteStraightBet {
+	amount: string;
+	value: number;
+}
+export interface RouletteSplitBet {
+	amount: string;
+	values: readonly [
+		number,
+		number
+	];
+}
+export interface RouletteStreetBet {
+	amount: string;
+	values: readonly [
+		number,
+		number,
+		number
+	];
+}
+export interface RouletteCornerBet {
+	amount: string;
+	values: readonly [
+		number,
+		number,
+		number,
+		number
+	];
+}
+export interface RouletteDoubleStreetBet {
+	amount: string;
+	values: readonly [
+		number,
+		number,
+		number,
+		number,
+		number,
+		number
+	];
+}
+export interface RouletteParityBet {
+	amount: string;
+	parity: Parity;
+}
+export interface RouletteColorBet {
+	amount: string;
+	color: Color;
+}
+export interface RouletteHalfBet {
+	amount: string;
+	half: Half;
+}
+export interface RouletteColumnBet {
+	amount: string;
+	column: Column;
+}
+export interface RouletteDozenBet {
+	amount: string;
+	dozen: Dozen;
+}
+export interface RouletteBasketBet {
+	amount: string;
+}
+export interface EuropeanRouletteInputs {
+	straightBets: RouletteStraightBet[];
+	splitBets: RouletteSplitBet[];
+	streetBets: RouletteStreetBet[];
+	cornerBets: RouletteCornerBet[];
+	doubleStreetBets: RouletteDoubleStreetBet[];
+	parityBets: RouletteParityBet[];
+	colorBets: RouletteColorBet[];
+	halfBets: RouletteHalfBet[];
+	columnBets: RouletteColumnBet[];
+	dozenBets: RouletteDozenBet[];
+}
+export interface AmericanRouletteInputs extends EuropeanRouletteInputs {
+	basketBets: RouletteBasketBet[];
+}
+export type RouletteStartAction = {
+	type: RouletteType.EUROPEAN;
+	inputs: EuropeanRouletteInputs;
+} | {
+	type: RouletteType.AMERICAN;
+	inputs: AmericanRouletteInputs;
+};
+export interface RouletteBetOutcomes {
+	winningBets: EuropeanRouletteInputs;
+	losingBets: EuropeanRouletteInputs;
+}
+export interface RouletteEndAction {
+	type: "european" | "american";
+	betOutcomes: RouletteBetOutcomes;
+	result: number[];
+}
+export interface Action {
+	id: string;
+	data: {
+		DICE?: DiceStartAction | EndAction;
+		KENO?: KenoStartAction | EndAction;
+		LIMBO?: LimboStartAction | LimboEndAction;
+		MINES?: MinesStartAction | EndAction;
+		DIAMONDS?: DiamondsStartAction | EndAction;
+		WHEEL?: WheelStartAction | EndAction;
+		PLINKO?: PlinkoStartAction | EndAction;
+		ADVANCED_DICE?: AdvancedDiceStartAction | EndAction;
+		ROULETTE?: RouletteStartAction | RouletteEndAction;
+		BACCARAT?: BaccaratGameInputs | BaccaratEndAction;
+	};
+	betAmount: string | null;
+	payoutAmount: string | null;
+	actionIndex: number;
+	type: OrigamiActionType;
+}
+export interface BetResult {
+	id: string;
+	nonce: number;
+	amount: string;
+	payout: string | null;
+	currency: Currency;
+	userId: string;
+	gameId: string;
+	multiplier: string | null;
+	tenantId: string;
+	clientSeed: string;
+	randomValue: string | null;
+	proof: string | null;
+	afterBalance: string | null;
+	tenantUserId: string;
+	betActions: Array<Action>;
 }
-export type BetMode = "Manual" | "Auto";
-export type AutobetToggleEvent = CustomEvent<AutobetEventPayload>;
-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 type AutobetSettingsWithId = AutobetEventPayload & {
+export type StartBetResponse = {
+	success: true;
+	data: BetResult;
+} | {
+	success: false;
+	error: string;
+};
+export type AutobetApiSettings = {
+	onWinStrategy: AfterBetEffect;
+	onLossStrategy: AfterBetEffect;
+	onWinPercentage: string;
+	onLossPercentage: string;
+	stopOnLoss: string;
+	stopOnProfit: string;
+	numberOfBets: number;
 	autobetId: string;
 	betIndex: number;
 	pnlSinceStart: string;
 };
-export interface GameBetResult {
-	pnl: Big$1;
-	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 styles: import("lit").CSSResult[];
-	protected onBetAmountChange: (_oldBetAmount: string, _newBetAmount: string) => void;
-	private gameConsumer;
-	get gameData(): gameContextType;
-	get isDemoMode(): boolean;
-	get isToggleDisabled(): boolean;
-	get areInputsDisabled(): boolean;
-	protected getDelay(normalDelay: number): number;
-	protected getAutobetDelay(): number;
-	protected forceUIUpdate(): Promise<void>;
-	protected executeInstantOrAnimated<T>(instantOperation: () => Promise<T> | T, animatedOperation: () => Promise<T> | T): Promise<T>;
-	/**
-	 * @deprecated Use sleep instead
-	 */
-	protected ensureMinimumDisplayTime(hasWin?: boolean, winDisplayTime?: number, lossDisplayTime?: number): Promise<void>;
-	disconnectedCallback(): void;
-	toggleAutobet(event: AutobetToggleEvent): Promise<void>;
-	protected abstract executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
-	protected adjustBetAmount(autobetSettings: AutobetSettingsWithId, gameOutcome: "Win" | "Loss" | "Draw", originalBetAmount: string, currentBetAmount: string): string;
-	protected isPnLWithinLimits(autobetSettings: AutobetSettingsWithId, totalPnL: Big$1): boolean;
-	protected updateHistoryWithBet(betResult: BetResult): void;
-	protected showError(message: string): void;
-	protected playWinFeedback(): void;
-}
-export interface DiceStartArgs extends BaseStartArgs {
-	language: Language;
-	direction: DiceDirection;
-	selectedValue: number;
-}
-declare class DiceApi {
-	private authToken;
-	private baseUrl;
-	constructor(authToken: string, baseUrl: string);
-	startBet(data: DiceStartArgs): Promise<{
-		success: true;
-		data: any;
-		error?: undefined;
-	} | {
-		success: false;
-		error: string;
-		data?: undefined;
-	}>;
-}
-declare class MockDiceApi {
-	private readonly edge;
-	constructor(edge: number);
-	startBet(data: DiceStartArgs): Promise<{
-		success: true;
-		data: BetResult;
-	}>;
-	private static getRandomValueInRange;
+export interface BaseStartArgs {
+	currency: Currency;
+	amount: string;
+	meta?: {
+		autobetSettings?: AutobetApiSettings;
+	};
 }
 export declare class DiceGame extends GameComponent {
 	static styles: import("lit").CSSResult[];
 	private diceDirection;
 	private selectedValue;
 	private isManualPlaying;
-	private showDice;
 	private isWin;
 	private resultValue;
 	private history;
 	private _multiplierInputValid;
 	private _winChanceInputValid;
+	private _rollValueInputValid;
 	private _diceManualEl?;
 	private _diceAutoEl?;
 	get isToggleDisabled(): boolean;
 	get areInputsDisabled(): boolean;
-	private getManualButton;
-	private getAutobetButton;
 	private isSpacebarDisabled;
 	private handleSpacebar;
 	diceRollOverToggle: () => void;
 	constructor();
 	private decreaseSlider;
 	private increaseSlider;
-	get diceApi(): DiceApi | MockDiceApi;
+	private addToHistory;
+	private readonly getDiceApi;
 	dicePlay(): Promise<void>;
 	private handleBetExecution;
-	addToHistory(multiplier: number, won: boolean, id: string): void;
 	protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
 	render(): import("lit-html").TemplateResult<1>;
 }
@@ -6476,49 +6447,11 @@ export declare class KenoGame extends GameComponent {
 	constructor();
 	firstUpdated(changedProperties: Map<string | number | symbol, unknown>): Promise<void>;
 }
-export interface LimboStartArgs extends BaseStartArgs {
-	language: Language;
-	targetMultiplier: number;
-}
-declare class LimboApi {
-	private authToken;
-	private 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<{
-		success: true;
-		data: any;
-		error?: undefined;
-	} | {
-		success: false;
-		error: string;
-		data?: undefined;
-	}>;
-	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;
-}
-declare class MockLimboApi {
-	private readonly edge;
-	constructor(edge: number);
-	startBet(data: LimboStartArgs): Promise<{
-		success: true;
-		data: BetResult;
-	}>;
-	private getRandomMultiplier;
-}
 export declare class LimboGame extends GameComponent {
 	static styles: import("lit").CSSResult[];
 	private targetMultiplier;
 	private resultMultiplier;
 	private isManualPlaying;
-	private isWin;
 	private history;
 	private betTargetMultiplier;
 	private betId;
@@ -6528,174 +6461,49 @@ export declare class LimboGame extends GameComponent {
 	private _limboAutoEl?;
 	get isToggleDisabled(): boolean;
 	get areInputsDisabled(): boolean;
-	private getManualButton;
-	private getAutobetButton;
-	get limboApi(): LimboApi | MockLimboApi;
+	private readonly getLimboApi;
+	constructor();
 	limboPlay(): Promise<void>;
 	private handleBetExecution;
+	private static readonly ANIMATION_TIMEOUT_MS;
+	private waitForAnimationComplete;
 	private isSpacebarDisabled;
 	private handleSpacebar;
-	constructor();
-	disconnectedCallback(): void;
 	protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
 	multiplierChange: (e: LimboMultiplierChangeEvent) => void;
 	calculateProfitOnWin(): string;
-	winChanceChange: (e: LimboWinChanceChangeEvent) => void;
 	addToHistory(multiplier: number, won: boolean, id: string): void;
 	multiplierAnimationEnd: (e: LimboMultiplierAnimationEndEvent) => void;
 	render(): import("lit-html").TemplateResult<1>;
 }
-export type MinesManualStartArgs = {
-	language: Language;
-	currency: Currency;
-	amount: string;
-	minesCount: number;
-};
-export type MinesNextArgs = {
-	betId?: string;
-	selectedTiles: number[];
-};
-export interface MinesAutoArgs extends BaseStartArgs {
-	language: Language;
-	minesCount: number;
-	selectedTiles: number[];
-}
-declare class MinesApi {
-	private authToken;
-	private baseUrl;
-	constructor(authToken: string, baseUrl: string);
-	startManualBet(data: MinesManualStartArgs): Promise<{
-		success: true;
-		data: any;
-		error?: undefined;
-	} | {
-		success: false;
-		error: string;
-		data?: undefined;
-	}>;
-	getActiveBet(): Promise<{
-		success: false;
-		error: string;
-		data?: undefined;
-	} | {
-		success: true;
-		data: BetResult;
-		error?: undefined;
-	}>;
-	selectTile(minesNextArgs: MinesNextArgs): Promise<{
-		success: true;
-		data: BetResult;
-		error?: undefined;
-	} | {
-		success: false;
-		error: string;
-		data?: undefined;
-	}>;
-	cashout(): Promise<{
-		success: true;
-		data: BetResult;
-		error?: undefined;
-	} | {
-		success: false;
-		error: string;
-		data?: undefined;
-	}>;
-	autobetPlay(data: MinesAutoArgs): Promise<{
-		success: true;
-		data: any;
-		error?: undefined;
-	} | {
-		success: false;
-		error: string;
-		data?: undefined;
-	}>;
-	static getInitialState: () => MinesState;
-	static deriveSelectedTiles: (betActions?: Action[] | null) => number[];
-	static deriveMineLocations: (betActions?: Action[] | null) => number[];
-	static getMinesBetInfo: (betActions: Action[]) => {
-		selected: number[];
-		mines: number[];
-	};
-	static deriveOutcome: (bet?: BetResult) => MinesGameOutcome | null;
-	static deriveAutoOutcome: (bet?: BetResult | null) => MinesGameOutcome | null;
-	static calculateMinesMultiplier: (gemsFound: number, mines: number, edge: number) => Big$1;
-	static getState: (bet: BetResult) => MinesState;
-}
-declare class MockMinesApi {
-	private readonly edge;
-	private static activeBet;
-	private static minePositions;
-	constructor(edge: number);
-	startManualBet(data: MinesManualStartArgs): Promise<{
-		success: true;
-		data: BetResult;
-	}>;
-	getActiveBet(): Promise<{
-		success: false;
-		error: string;
-		data?: undefined;
-	} | {
-		success: true;
-		data: BetResult;
-		error?: undefined;
-	}>;
-	selectTile(data: MinesNextArgs): Promise<{
-		success: false;
-		error: string;
-		data?: undefined;
-	} | {
-		success: true;
-		data: BetResult;
-		error?: undefined;
-	}>;
-	cashout(): Promise<{
-		success: false;
-		error: string;
-		data?: undefined;
-	} | {
-		success: true;
-		data: BetResult;
-		error?: undefined;
-	}>;
-	autobetPlay(data: MinesAutoArgs): Promise<{
-		success: true;
-		data: BetResult;
-	}>;
-	private static getRandomValueInRange;
-	private static generateMinePositions;
-	private static createBetAction;
-	private createMockBetResult;
-}
 export declare class MinesGame extends GameComponent {
 	private minesCount;
 	private autobetSelectedTiles;
 	private minesData;
 	private isLoading;
 	private isSelectingRandomTile;
-	private history;
 	private isCheckingForSession;
 	private loadingTiles;
 	static styles: import("lit").CSSResult[];
 	private _minesManualEl?;
 	private _minesAutoEl?;
-	private getButton;
-	private clickButton;
-	private _playSound;
-	private _getGemPitchFromHits;
-	private _playGem;
-	private authTokenWatcher;
+	private readonly sessionWatcher;
 	get isToggleDisabled(): boolean;
 	get areInputsDisabled(): boolean;
 	get isGameActive(): boolean;
-	get minesApi(): MinesApi | MockMinesApi;
-	addToHistory(multiplier: number, won: boolean, id: string): void;
+	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;
-	get getMinesState(): MinesState | null;
 	protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
 	toggleAutobet(event: AutobetToggleEvent): Promise<void>;
-	private minesClickHandler;
+	private readonly minesClickHandler;
 	minesManualStart(): Promise<void>;
 	minesChooseRandomTile(): Promise<void>;
 	minesNext(selectedTile: number): Promise<void>;
@@ -6705,7 +6513,10 @@ export declare class MinesGame extends GameComponent {
 	onAutobetChange(): void;
 	private isSpacebarDisabled;
 	private handleSpacebar;
-	private pickRandomTile;
+	private isRandomTileHotkeyDisabled;
+	private handleRandomTileHotkey;
+	private isCashoutHotkeyDisabled;
+	private handleCashoutHotkey;
 	private waitForAnimationsComplete;
 	constructor();
 	render(): import("lit-html").TemplateResult<1>;