@betorigami/games 2.10.1 → 2.11.0

package/dist/components/blitz/BlitzControls/BlitzManual.d.ts

@@ -0,0 +1,25 @@
+import { Currency } from '../../../shared/constants';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Language } from '../../../translations';
+export declare class BlitzManual extends OrigamiElement {
+    inputsDisabled: boolean;
+    isPlaying: boolean;
+    isGameActive: boolean;
+    showCardsRemaining: boolean;
+    picks: number;
+    maxPicks: number;
+    minPicks: number;
+    cardsRemaining: number;
+    edge: number;
+    profitOnWin: string;
+    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/blitz/BlitzControls/BlitzPicksInput.d.ts

@@ -0,0 +1,15 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Language } from '../../../translations';
+export declare class BlitzPicksInput extends OrigamiElement {
+    picks: number;
+    maxPicks: number;
+    minPicks: number;
+    edge: number;
+    disabled: boolean;
+    language: Language;
+    static styles: import('lit').CSSResult[];
+    private get pickOptions();
+    private updatePicks;
+    private get multiplier();
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/blitz/BlitzGame.d.ts

@@ -0,0 +1,43 @@
+import { AutobetSettingsWithId, GameBetResult, GameComponent } from '../shared/GameComponent';
+export declare class BlitzGame extends GameComponent {
+    static styles: import('lit').CSSResult[];
+    private picks;
+    private isManualPlaying;
+    private cardDetails;
+    private revealCardIndex;
+    private progressActive;
+    private gameOutcome;
+    private winPopupBet;
+    private _blitzManualEl?;
+    private _blitzAutoEl?;
+    private _blitzContentEl?;
+    private readonly getBlitzApi;
+    get isToggleDisabled(): boolean;
+    get areInputsDisabled(): boolean;
+    private get minPicks();
+    private get maxPicks();
+    constructor();
+    private isSpacebarDisabled;
+    private arePicksHotkeysDisabled;
+    private handleSpacebar;
+    private changePicks;
+    private handlePicksChange;
+    private get multiplier();
+    private get profitOnWin();
+    private get cardsRemaining();
+    private get showCardsRemaining();
+    private get progressDurationMs();
+    blitzPlay(): Promise<void>;
+    private handleBetExecution;
+    private revealCardsInstant;
+    private revealCards;
+    private scheduleIntermediateReveals;
+    private completeReveal;
+    private revealCard;
+    private waitForProgressComplete;
+    private prefersReducedMotion;
+    private nextAnimationFrame;
+    private setRevealOutcome;
+    protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/blitz/BlitzGame.styles.d.ts

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

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

@@ -0,0 +1,21 @@
+import { BaseStartArgs } from '../../shared/bet.types';
+import { ErrorBetResult, SuccessBetResult } from '../../shared/provider-api/bet-result';
+import { BlitzCardDto } from './blitz.utils';
+export interface BlitzStartArgs extends BaseStartArgs {
+    gameInputs: {
+        pickCount: number;
+    };
+}
+export type SuccessBlitzBetResult = SuccessBetResult<number[]> & {
+    readonly cards: BlitzCardDto[];
+};
+export type BlitzBetResult = SuccessBlitzBetResult | ErrorBetResult;
+export interface IBlitzApi {
+    startBet(data: BlitzStartArgs): Promise<BlitzBetResult>;
+}
+export declare class BlitzApi implements IBlitzApi {
+    private readonly authToken;
+    private readonly baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: BlitzStartArgs): Promise<BlitzBetResult>;
+}

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

@@ -0,0 +1,10 @@
+import { BlitzBetResult, BlitzStartArgs, IBlitzApi } from './blitz.api';
+export declare class MockBlitzApi implements IBlitzApi {
+    private readonly getEdge;
+    private readonly getBalance;
+    constructor(getEdge: () => number, getBalance: () => number);
+    startBet(data: BlitzStartArgs): Promise<BlitzBetResult>;
+    private static drawCards;
+    private static isValidPicks;
+    private static getCardDto;
+}

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

@@ -0,0 +1,45 @@
+import { default as Big } from 'big.js';
+import { Card, CardDto } from '@betorigami/game-calculations';
+export declare const BLITZ_DEFAULT_MIN_PICKS: number;
+export declare const BLITZ_DEFAULT_MAX_PICKS: number;
+export declare const BLITZ_DEFAULT_PICKS = 10;
+export declare const BLITZ_CARDS_PER_DECK = 52;
+/** Strip out the numeric value, as it may differ from our representation */
+export type BlitzCardDto = Pick<CardDto, 'rank' | 'suit'>;
+export type BlitzSuit = 'DIAMONDS' | 'HEARTS' | 'SPADES' | 'CLUBS';
+export type BlitzCardValue = 'A' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | 'J' | 'Q' | 'K';
+export interface BlitzCardDetail {
+    suit: BlitzSuit;
+    value: BlitzCardValue;
+}
+export type BlitzGameOutcome = 'Win' | 'Loss' | null;
+interface RevealProgressArgs {
+    totalCards: number;
+    revealCardIndex: number;
+}
+export declare class BlitzUtils {
+    static readonly revealDuration = 150;
+    static readonly delayBeforeComplete = 50;
+    static getRevealedCount({ totalCards, revealCardIndex }: RevealProgressArgs): number;
+    static getRevealProgressScale({ totalCards, revealCardIndex }: RevealProgressArgs): number;
+    static getRevealTargetIndex(cards: readonly BlitzCardDetail[]): number | null;
+    static getRevealTargetCount(cards: readonly BlitzCardDetail[]): number;
+    static getRevealProgressDurationMs(cards: readonly BlitzCardDetail[], revealDelayMs: number): number;
+    /** Ensures pick count is within our min/max limits */
+    static clampPickCount(picks: number, min: number, max: number): number;
+    static cardKey(card: BlitzCardDetail): string;
+    static getCardDetails(card: BlitzCardDto): BlitzCardDetail;
+    static toOrigamiCard(card: BlitzCardDetail): Card;
+    static getLossIndex(cards: readonly BlitzCardDetail[]): number | null;
+    static hasWon(cards: readonly BlitzCardDto[]): boolean;
+    static calculateMultiplier(picks: number, edge: number): Big;
+    static formatMultiplier(multiplier: Big): string;
+    static getMaxPicksForPayout({ minPicks, maxPicks, edge, minBet, maxPayout, }: {
+        minPicks: number;
+        maxPicks: number;
+        edge: number;
+        minBet: number | null;
+        maxPayout: number | null;
+    }): number;
+}
+export {};

package/dist/components/diamonds/DiamondsContent/DiamondSlot.d.ts

@@ -0,0 +1,17 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class DiamondSlot extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    index: number;
+    diamondIndex: number | null;
+    exiting: boolean;
+    dropDelay: string;
+    slotColors: {
+        placeholder: string;
+        bar: string;
+    } | null;
+    constrainedWidth: boolean;
+    gameData?: gameContextType;
+    private get gems();
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/diamonds/DiamondsContent/DiamondSlot.styles.d.ts

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

package/dist/components/diamonds/DiamondsContent/DiamondsContent.d.ts

@@ -0,0 +1,28 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class DiamondsContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    gameData: gameContextType;
+    isDesktop: boolean;
+    isPlaying: boolean;
+    resultGems: number[] | null;
+    autobetInProgress: boolean;
+    instantReveal: boolean;
+    private hoveredMultiplierIndex;
+    private tooltipBottom;
+    private diamondIndices;
+    private appearedDiamonds;
+    private instantRevealAnimation;
+    private exiting;
+    private scheduledTimeouts;
+    get soundDisabled(): boolean;
+    private clearScheduledTasks;
+    private resetGemState;
+    private startProgressiveReveal;
+    onresultGemsChange(prev?: unknown, next?: unknown): void;
+    disconnectedCallback(): void;
+    private updateTooltipPosition;
+    private handleMultiplierHover;
+    private handleMultiplierLeave;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/diamonds/DiamondsContent/DiamondsContent.styles.d.ts

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

package/dist/components/diamonds/DiamondsContent/DiamondsMultiplierItem.d.ts

@@ -0,0 +1,12 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class MultiplierItem extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    index: number;
+    highlightLevel: number | null;
+    diamondIndices: number[];
+    appearedDiamonds: boolean[];
+    multiplier: number;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/diamonds/DiamondsContent/DiamondsMultiplierItem.styles.d.ts

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

package/dist/components/diamonds/DiamondsContent/DiamondsProfitTooltip.d.ts

@@ -0,0 +1,14 @@
+import { Language } from '../../../translations';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Currency } from '../../../shared/constants';
+export declare class ProfitTooltip extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    hoveredMultiplierIndex: number | null;
+    tooltipBottom: number;
+    betAmount: string;
+    currencyDecimals: number;
+    language: Language;
+    multiplier: number;
+    currency: Currency;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/diamonds/DiamondsContent/DiamondsProfitTooltip.styles.d.ts

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

package/dist/components/diamonds/DiamondsContent/DiamondsSlots.d.ts

@@ -0,0 +1,13 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class DiamondsSlots extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    diamondIndices: number[] | null;
+    slotColors: Array<{
+        placeholder: string;
+        bar: string;
+    } | null>;
+    exiting: boolean;
+    constrainedWidth: boolean;
+    instantRevealAnimation: boolean;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/diamonds/DiamondsContent/DiamondsSlots.styles.d.ts

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

package/dist/components/diamonds/DiamondsControls/DiamondsAuto.d.ts

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

package/dist/components/diamonds/DiamondsControls/DiamondsControls.styles.d.ts

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

package/dist/components/diamonds/DiamondsControls/DiamondsManual.d.ts

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

package/dist/components/diamonds/DiamondsGame.d.ts

@@ -0,0 +1,18 @@
+import { AutobetSettingsWithId, GameBetResult, GameComponent } from '../shared/GameComponent';
+import { DiamondsApi } from './diamonds.api';
+import { MockDiamondsApi } from './diamonds.mock.api';
+export declare class DiamondsGame extends GameComponent {
+    static styles: import('lit').CSSResult[];
+    private isManualPlaying;
+    private resultGems;
+    private _diamondsManualEl?;
+    private _diamondsAutoEl?;
+    constructor();
+    get isToggleDisabled(): boolean;
+    get diamondsApi(): DiamondsApi | MockDiamondsApi;
+    private animationCompletedPromise;
+    private handleBetExecution;
+    diamondsManualPlay(): Promise<void>;
+    protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/diamonds/DiamondsGame.styles.d.ts

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

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

@@ -0,0 +1,11 @@
+import { BaseStartArgs, StartBetResponse } from '../../shared/bet.types';
+import { Language } from '../../translations';
+export interface DiamondsStartArgs extends BaseStartArgs {
+    language: Language;
+}
+export declare class DiamondsApi {
+    private authToken;
+    private baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: DiamondsStartArgs): Promise<StartBetResponse>;
+}

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

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

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

@@ -0,0 +1,100 @@
+export declare const DIAMOND_REVEAL_DELAY = 300;
+export declare const DIAMOND_EXIT_DELAY = 200;
+/**
+ * SVG template for diamond icon in multiplier list
+ */
+export declare const diamondIconSvg: (fill: string, stroke: string) => import('lit').TemplateResult<1>;
+export type DiamondsEdge = 1 | 2 | 3 | 4 | 8;
+/**
+ * Multiplier structure for each result type
+ */
+export interface DiamondsMultipliers {
+    PAIR: number;
+    TWO_PAIR: number;
+    THREE_OF_A_KIND: number;
+    FULL_HOUSE: number;
+    FOUR_OF_A_KIND: number;
+    FIVE_OF_A_KIND: number;
+}
+/**
+ * Gets multipliers for a specific edge
+ */
+export declare function getMultipliersForEdge(edge: number): DiamondsMultipliers;
+/**
+ * Determines the multiplier based on the result rolls
+ */
+export declare function getMultiplierByResult(edge: number, rolls: number[]): number;
+/**
+ * Gets multiplier for a specific level index (0-6)
+ * Level 0 = No match, Level 1 = Pair, Level 2 = Two Pair, etc.
+ */
+export declare function getMultiplierForLevel(edge: number, level: number): number;
+/**
+ * Gets the maximum multiplier for a given house edge
+ */
+export declare function getBetMaxMultiplier(edge: number): number;
+/**
+ * Complete configuration for each level (index = level)
+ * Level 0 = No match, Level 6 = Five of a kind
+ * Total outcomes: 7^5 = 16,807
+ */
+export declare const LEVEL_CONFIG: {
+    winChance: number;
+    pattern: {
+        filled: boolean;
+        outlined: boolean;
+    }[];
+}[];
+/**
+ * Detailed match information including which specific gem types form the matches
+ */
+export type DiamondMatchInfo = {
+    level: number;
+    five: number | null;
+    four: number | null;
+    three: number | null;
+    pairs: number[];
+};
+/**
+ * Calculates both the level and detailed match information for diamonds
+ *
+ * @param gemIndices - Array of gem type indices (0-6)
+ * @param appearedMask - Boolean array indicating which gems have appeared
+ * @returns Object containing level and matched gem details
+ */
+export declare function calculateDiamondsMatch(gemIndices: number[], appearedMask: boolean[]): DiamondMatchInfo;
+/**
+ * Calculates which slots should have color highlights based on matched gems
+ *
+ * @param gemIndices - Array of gem type indices for each slot
+ * @param appearedMask - Boolean array indicating which gems have appeared
+ * @returns Array of slot colors (null if no highlight needed)
+ */
+export declare function calculateSlotColors(gemIndices: number[], appearedMask: boolean[]): Array<{
+    placeholder: string;
+    bar: string;
+} | null>;
+export declare const calculateAllGemRevealPitches: (gemIndices: number[]) => number[];
+/**
+ * Creates a diamond icon SVG with specific fill and stroke colors
+ *
+ * @param filled - Whether the diamond should be filled
+ * @param outlined - Whether the diamond should be outlined only
+ * @param fillOverride - Optional override for fill color
+ * @param strokeOverride - Optional override for stroke color
+ * @returns Lit HTML template with diamond icon
+ */
+export declare function getDiamondIcon(filled: boolean, outlined: boolean, fillOverride?: string, strokeOverride?: string): import('lit').TemplateResult<1>;
+/**
+ * Gets colors for multiplier level diamonds based on current match
+ *
+ * @param level - The level (0-6) to get colors for
+ * @param gemIndices - Array of gem type indices (0-6)
+ * @param appearedMask - Boolean array indicating which gems have appeared
+ * @returns Array of 5 diamond colors: { fill?: string, stroke?: string }
+ */
+export declare function getMultiplierDiamondColors(level: number, gemIndices: number[], appearedMask: boolean[]): Array<{
+    fill?: string;
+    stroke?: string;
+}>;
+export declare function getRevealDelay(index: number, instantReveal: boolean): string;

package/dist/components/diamonds/svgs/diamond-gems.d.ts

@@ -0,0 +1 @@
+export declare const diamondGems: import('lit').TemplateResult<1>[];

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

@@ -0,0 +1,23 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { DiceHistory } from '../DiceGame';
+import { DiceDirection } from '../../../shared/calculations/games/dice';
+import { SoundEffectsController } from '../../../controllers/sound/sound-effects.controller';
+import { Language } from '../../../translations';
+export declare class DiceContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    selectedValue: number;
+    diceDirection: DiceDirection;
+    isPlaying: boolean;
+    isWin: boolean;
+    edge: number;
+    resultValue: number | null;
+    history: DiceHistory[];
+    isDesktop: boolean;
+    diceMinMultiplier: number | null;
+    language: Language;
+    hotkeysOpenEnabled: boolean;
+    soundEffects?: SoundEffectsController;
+    instantBetEnabled: boolean;
+    private renderSlider;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/dice/DiceContent/DiceContent.styles.d.ts

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

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

@@ -0,0 +1,29 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Language } from '../../../translations';
+import { DiceDirection } from '../../../shared/calculations/games/dice';
+export declare class DiceContentBottom extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    selectedValue: number;
+    diceDirection: DiceDirection;
+    disabled: boolean;
+    language: Language;
+    edge: 1 | 2 | 3 | 4 | 8;
+    diceMinMultiplier: number | null;
+    hotkeysOpenEnabled: boolean;
+    private _winChanceInputValue;
+    private _multiplierInputValue;
+    private _rollOverInputValue;
+    private _winChanceFocused;
+    private _multiplierFocused;
+    private _rollOverFocused;
+    _previousMultiplierInputValue: string;
+    _previousWinChanceInputValue: string;
+    set winChanceInputValue(value: string);
+    set multiplierInputValue(value: string);
+    private getRollRange;
+    private emitRollValueValidity;
+    setWinChanceValue(value: string): void;
+    setMultiplierValue(value: string): void;
+    selectedValueChangeHandler(): void;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/dice/DiceContentBottom/DiceContentBottom.styles.d.ts

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

package/dist/components/dice/DiceControls/DiceAuto.d.ts

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

package/dist/components/dice/DiceControls/DiceControls.styles.d.ts

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

package/dist/components/dice/DiceControls/DiceManual.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 DiceManual extends OrigamiElement {
+    isPlaying: boolean;
+    profitOnWin: string;
+    betDisabled: boolean;
+    inputsDisabled: 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/dice/DiceGame.d.ts

@@ -0,0 +1,34 @@
+import { AutobetSettingsWithId, GameBetResult, GameComponent } from '../shared/GameComponent';
+export interface DiceHistory {
+    multiplier: number;
+    won: boolean;
+    id: string;
+}
+export declare class DiceGame extends GameComponent {
+    static styles: import('lit').CSSResult[];
+    private diceDirection;
+    private selectedValue;
+    private isManualPlaying;
+    private isWin;
+    private resultValue;
+    private history;
+    private _multiplierInputValid;
+    private _winChanceInputValid;
+    private _rollValueInputValid;
+    private _diceManualEl?;
+    private _diceAutoEl?;
+    get isToggleDisabled(): boolean;
+    get areInputsDisabled(): boolean;
+    private isSpacebarDisabled;
+    private handleSpacebar;
+    diceRollOverToggle: () => void;
+    constructor();
+    private decreaseSlider;
+    private increaseSlider;
+    private addToHistory;
+    private readonly getDiceApi;
+    dicePlay(): Promise<void>;
+    private handleBetExecution;
+    protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/dice/DiceGame.styles.d.ts

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

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

@@ -0,0 +1,31 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { SoundEffectsController } from '../../../controllers/sound/sound-effects.controller';
+import { Language } from '../../../translations';
+export declare class DiceSlider extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    step: number;
+    isRollLower: boolean;
+    value: number;
+    clampMin?: number;
+    clampMax?: number;
+    disabled: boolean;
+    resultValue: number | null;
+    showDice: boolean;
+    isWin: boolean;
+    inGameDisplay: boolean;
+    persistResult: boolean;
+    ignoreInstantBet: boolean;
+    soundEffects?: SoundEffectsController;
+    language: Language;
+    instantBetEnabled: boolean;
+    private isResultVisible;
+    private dimLosingSide;
+    private fadeOutTimer?;
+    private lastStepValue;
+    private lastSoundPlayTime;
+    disconnectedCallback(): void;
+    updated(changedProperties: Map<string, unknown>): void;
+    private handleChange;
+    private handleFocus;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/dice/DiceSlider/DiceSlider.styles.d.ts

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