@betorigami/games 0.0.1

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

@@ -0,0 +1,14 @@
+import { DiceDirection } from 'shufflecom-calculations';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { DiceHistory } from '../DiceGame';
+export declare class DiceContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    selectedValue: number;
+    diceDirection: DiceDirection;
+    isPlaying: boolean;
+    showDice: boolean;
+    isWin: boolean;
+    resultValue: number | null;
+    history: DiceHistory[];
+    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,15 @@
+import { DiceDirection } from 'shufflecom-calculations';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class DiceContentBottom extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    selectedValue: number;
+    diceDirection: DiceDirection;
+    winChanceInputFocused: boolean;
+    multiplierInputFocused: boolean;
+    winChanceInputValue: string;
+    multiplierInputValue: string;
+    handleMultiplierBlur(): void;
+    handleWinChanceBlur(): void;
+    updated(changedProperties: Map<string | number | symbol, unknown>): 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,9 @@
+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;
+    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,11 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Currency } from '../../../shared/constants';
+export declare const currencyIcon: import('lit').TemplateResult<1>;
+export declare class DiceManual extends OrigamiElement {
+    isPlaying: boolean;
+    profitOnWin: string;
+    betDisabled: boolean;
+    currency: Currency;
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,47 @@
+import { DiceMultiplierChangeEvent, DiceWinChanceChangeEvent, SliderChangeEvent } from '../../shared/event-map';
+import { AutobetSettings, GameBetResult, GameComponent } from '../shared/GameComponent';
+import { gameContextType } from '../shared/context/game.context';
+import { DiceApi } from './dice.api';
+import { MockDiceApi } from './dice.mock.api';
+export interface DiceHistory {
+    multiplier: number;
+    won: boolean;
+    id: string;
+}
+export declare class DiceGame extends GameComponent {
+    private diceDirection;
+    private selectedValue;
+    private isManualPlaying;
+    authToken: string;
+    private showDice;
+    private isWin;
+    private resultValue;
+    private history;
+    get diceApi(): DiceApi | MockDiceApi;
+    gameData?: gameContextType;
+    dicePlay(): Promise<void>;
+    addToHistory(multiplier: number, won: boolean): void;
+    protected executeBet(_autobetSettings: AutobetSettings, currentBetAmount: string): Promise<GameBetResult>;
+    sliderInputChange: (e: SliderChangeEvent) => void;
+    diceMultiplierChange: (e: DiceMultiplierChangeEvent) => void;
+    diceWinChanceChange: (e: DiceWinChanceChangeEvent) => void;
+    diceRollOverToggle: () => void;
+    render(): import('lit').TemplateResult<1>;
+}
+/**
+ * Done
+ * Disable slider and DiceContentBottom inputs when game is in play
+ * Height of cube svg
+ * markers are not aligned with slider knob
+ * Animation for results sliding in. And color
+ * Footer should show icon for game stats in mobile
+ * Autobet games input should be an input with an icon when input is '0'
+ * History pills should be a button with hover and pressed states
+ * Height of game content in tablet
+ * Order of buttons in sidebar in mobile mode (bet btn on top, toggle at the bottom)
+ *
+ * Things to improve:
+ * Autobet increase/reset button should be wider (should it be wider?)
+ * remove the display:grid in style tag in DiceContentBottom
+ * Dice slider overflows in mobile due to width of 382px on the history pills. Set it to absolute to prevent this
+ */

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

@@ -0,0 +1,16 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class DiceSlider extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    step: number;
+    isRollLower: boolean;
+    value: number;
+    min: number;
+    max: number;
+    disabled: boolean;
+    resultValue: number | null;
+    showDice: boolean;
+    isWin: boolean;
+    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;

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

@@ -0,0 +1,71 @@
+import { Currency } from '../../shared/constants';
+import { OrigamiActionType } from '../../shared/origami-action.type';
+declare enum DiceDirection {
+    ABOVE = "ABOVE",
+    BELOW = "BELOW"
+}
+export interface DiceData {
+    resultValue: number;
+    userValue: number;
+    userDiceDirection: DiceDirection;
+}
+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;
+};
+export 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 {};

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

@@ -0,0 +1,13 @@
+import { BetResult, DiceApi, DiceStartArgs } from './dice.api';
+export interface MockDiceSettings {
+    shouldWin: boolean;
+    resultValue?: number;
+    multiplier?: number;
+}
+export declare class MockDiceApi extends DiceApi {
+    private static getRandomValueInRange;
+    startBet(data: DiceStartArgs): Promise<{
+        success: true;
+        data: BetResult;
+    }>;
+}

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

@@ -0,0 +1,17 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { KenoRiskLevel } from 'shufflecom-calculations';
+export declare class KenoContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    selectedTiles: number[];
+    resultTiles: number[];
+    isPlaying: boolean;
+    gameOver: boolean;
+    multipliersForSelectedTiles: number;
+    wonAmount: string | null;
+    gameWinPopupShowing: boolean;
+    multiplier: number | null;
+    risk: KenoRiskLevel;
+    betAmount: string;
+    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/KenoContent/KenoContentBottom.d.ts

@@ -0,0 +1,14 @@
+import { KenoRiskLevel } from 'shufflecom-calculations';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class KenoContentBottom extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    selectedTiles: number[];
+    risk: KenoRiskLevel;
+    betAmount: string;
+    hitCount: number;
+    multipliersForSelectedTiles: number;
+    private hoverItemIndex;
+    handleMouseOver(index: number, event: MouseEvent): void;
+    handleMouseLeave(): void;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/keno/KenoContent/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,9 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class KenoAuto extends OrigamiElement {
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    disableBet: boolean;
+    readonly autobetInProgress = false;
+    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,10 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { KenoRiskLevel } from 'shufflecom-calculations';
+export declare class KenoManual extends OrigamiElement {
+    inputsDisabled: boolean;
+    risk: KenoRiskLevel;
+    isPlaying: boolean;
+    disableBet: boolean;
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,30 @@
+import { KenoRiskChangeEvent, KenoTileClickEvent } from '../../shared/event-map';
+import { AutobetSettings, GameBetResult, GameComponent } from '../shared/GameComponent';
+import { KenoApi } from './keno.api';
+import { MockKenoApi } from './keno.mock.api';
+export interface KenoHistory {
+    multiplier: number;
+    won: boolean;
+}
+export declare class KenoGame extends GameComponent {
+    private isManualPlaying;
+    private history;
+    private selectedTiles;
+    private resultTiles;
+    authToken: string;
+    gameWinPopupShowing: boolean;
+    private gameOver;
+    private wonAmount;
+    private kenoRisk;
+    private autoselectRunning;
+    get kenoApi(): KenoApi | MockKenoApi;
+    kenoPlay(): Promise<void>;
+    addToHistory(multiplier: number, won: boolean): void;
+    protected executeBet(_autobetSettings: AutobetSettings, currentBetAmount: string): Promise<GameBetResult>;
+    handleTileClick: (e: KenoTileClickEvent) => void;
+    handleRiskChange: (e: KenoRiskChangeEvent) => void;
+    autoPick: () => Promise<void>;
+    clearTable: () => void;
+    newGame: () => void;
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,24 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class KenoGrid extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    selectedTiles: number[];
+    resultTiles: number[];
+    popupShowing: boolean;
+    isPlaying: boolean;
+    gameOver: boolean;
+    wonAmount: string | null;
+    enableSounds: boolean;
+    ariaLabel: string;
+    private audioRefs;
+    private winAudioRef;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    get selectedCount(): number;
+    get hitCount(): number;
+    private initializeSounds;
+    private cleanupSounds;
+    updated(changedProps: Map<string, unknown>): void;
+    private handleTileClick;
+    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,16 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+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;
+    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,67 @@
+import { KenoRiskLevel } from 'shufflecom-calculations';
+import { Currency } from '../../shared/constants';
+import { OrigamiActionType } from '../../shared/origami-action.type';
+export declare const MAX_SELECTABLE_TILES = 10;
+export declare const TOTAL_KENO_TILES = 40;
+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;
+}
+export interface Action {
+    id: string;
+    data: {
+        keno: KenoData;
+    };
+    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 KenoStartArgs = {
+    currency: Currency;
+    amount: string;
+    windowId?: string;
+    usdAmount?: number;
+    riskLevel: KenoRiskLevel;
+    selectedTiles: number[];
+};
+export declare class KenoApi {
+    private authToken;
+    private baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: KenoStartArgs): Promise<{
+        success: true;
+        data: BetResult;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        data?: undefined;
+    }>;
+}

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

@@ -0,0 +1,15 @@
+import { BetResult, KenoApi, KenoStartArgs } from './keno.api';
+export interface MockKenoSettings {
+    shouldWin?: boolean;
+    resultTiles?: number[];
+    multiplier?: number;
+    hitCount?: number;
+}
+export declare class MockKenoApi extends KenoApi {
+    private static generateRandomTiles;
+    private static calculateMultiplier;
+    startBet: (data: KenoStartArgs) => Promise<{
+        success: true;
+        data: BetResult;
+    }>;
+}

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

@@ -0,0 +1,13 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { LimboHistory } from '../LimboGame';
+export declare class LimboContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    targetMultiplier: number;
+    betTargetMultiplier: number;
+    history: LimboHistory[];
+    resultMultiplier: number | null;
+    isWin: boolean;
+    betId: string;
+    isPlaying: boolean;
+    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,14 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class LimboGameStats extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    targetMultiplier: number;
+    disabled: boolean;
+    winChanceInputFocused: boolean;
+    multiplierInputFocused: boolean;
+    winChanceInputValue: string;
+    multiplierInputValue: string;
+    handleWinChanceBlur(): void;
+    handleMultiplierBlur(): 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,9 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class LimboAuto extends OrigamiElement {
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    profitOnWin: string;
+    betDisabled: 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,11 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class LimboManual extends OrigamiElement {
+    inputsDisabled: boolean;
+    isPlaying: boolean;
+    profitOnWin: string;
+    betDisabled: boolean;
+    gameData?: gameContextType;
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,27 @@
+import { LimboMultiplierAnimationEndEvent, LimboMultiplierChangeEvent, LimboWinChanceChangeEvent } from '../../shared/event-map';
+import { AutobetSettings, GameBetResult, GameComponent } from '../shared/GameComponent';
+import { LimboApi } from './limbo.api';
+import { MockLimboApi } from './limbo.mock.api';
+export interface LimboHistory {
+    multiplier: number;
+    won: boolean;
+    id: string;
+}
+export declare class LimboGame extends GameComponent {
+    private targetMultiplier;
+    private resultMultiplier;
+    private isManualPlaying;
+    authToken: string;
+    private isWin;
+    private history;
+    private betTargetMultiplier;
+    private betId;
+    get limboApi(): LimboApi | MockLimboApi;
+    limboPlay(): Promise<void>;
+    protected executeBet(_autobetSettings: AutobetSettings, currentBetAmount: string): Promise<GameBetResult>;
+    multiplierChange: (e: LimboMultiplierChangeEvent) => void;
+    calculateProfitOnWin(): string;
+    winChanceChange: (e: LimboWinChanceChangeEvent) => void;
+    multiplierAnimationEnd: (e: LimboMultiplierAnimationEndEvent) => void;
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,17 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class LimboMultiplier extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    resultMultiplier: number | null;
+    isWin: boolean;
+    betId: string;
+    betTargetMultiplier: number;
+    private currentValue;
+    private animationFrame;
+    private startTime;
+    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,62 @@
+import { Currency } from '../../shared/constants';
+import { OrigamiActionType } from '../../shared/origami-action.type';
+export interface LimboData {
+    targetMultiplier: number;
+    resultMultiplier: number;
+}
+interface Action {
+    id: string;
+    data: {
+        limbo: LimboData;
+    };
+    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 LimboStartArgs = {
+    currency: Currency;
+    amount: string;
+    windowId?: string;
+    usdAmount?: number;
+    targetMultiplier: number;
+};
+export declare class LimboApi {
+    private authToken;
+    private baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet: (data: LimboStartArgs) => Promise<{
+        success: true;
+        data: BetResult;
+        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 {};

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

@@ -0,0 +1,13 @@
+import { BetResult, LimboApi, LimboStartArgs } from './limbo.api';
+export interface MockLimboSettings {
+    shouldWin: boolean;
+    resultMultiplier?: string;
+    multiplier?: number;
+}
+export declare class MockLimboApi extends LimboApi {
+    private static getRandomMultiplier;
+    startBet: (data: LimboStartArgs) => Promise<{
+        success: true;
+        data: BetResult;
+    }>;
+}

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

@@ -0,0 +1,13 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class MinesAuto extends OrigamiElement {
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    profitOnWin: string;
+    minesCount: number;
+    gameData?: gameContextType;
+    static styles: import('lit').CSSResult[];
+    private _handleMinesCountChange;
+    render(): import('lit').TemplateResult<1>;
+}

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

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