@betorigami/games 2.10.1 → 2.11.0

package/dist/components/shared/BetResultModal/BetResultModal.d.ts

@@ -0,0 +1,31 @@
+import { BetResult } from '../../../shared/bet.types';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { OrigamiGame } from '../../../shared/constants';
+import { gameContextType } from '../context/game.context';
+export declare class BetResultModal extends OrigamiElement {
+    gameData?: gameContextType;
+    static styles: import('lit').CSSResult[];
+    betId: string;
+    betData: Omit<BetResult, 'afterBalance'> | null;
+    private _copiedId;
+    private _copyTimeout;
+    private gameConsumer;
+    private betResultCache;
+    private _cachedDataExtractor;
+    private _cachedBetData;
+    betIdUpdated(): Promise<void>;
+    disconnectedCallback(): void;
+    private _handleCopyId;
+    private _getDataExtractor;
+    private _formatMonetaryAmount;
+    private _calculateMultiplier;
+    private _calculatePayout;
+    private _getCurrencyDisplay;
+    private openVerifyOutcomeModal;
+    triggerVerify(): void;
+    get gameType(): OrigamiGame;
+    private renderLoading;
+    private _getAdvancedDiceRollTypeLabel;
+    private _formatAdvancedDiceBounds;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/BetResultModal/BetResultModal.styles.d.ts

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

package/dist/components/shared/Button/Button.d.ts

@@ -0,0 +1,26 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../context/game.context';
+export type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'icon' | 'icon-secondary';
+export declare class Button extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    gameData: gameContextType;
+    variant: ButtonVariant;
+    disabled: boolean;
+    ariaLabel: string | null;
+    ariaDescribedby: string | null;
+    type: string;
+    isLoading: boolean;
+    fullWidth: boolean;
+    hotkey?: string;
+    private _handlePointerDown;
+    private _handleClick;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Button/Button.styles.d.ts

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

package/dist/components/shared/Button/ButtonGroup.d.ts

@@ -0,0 +1,5 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class ButtonGroup extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Button/ButtonGroup.styles.d.ts

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

package/dist/components/shared/ChipStack/ChipStack.d.ts

@@ -0,0 +1,10 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+/**
+ * Renders a stack of chips at a betting position.
+ * Contains the stacking logic and label rendering.
+ */
+export declare class ChipStack extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    amount: number;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/ChipStack/ChipStack.styles.d.ts

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

package/dist/components/shared/ChipTableGameComponent.d.ts

@@ -0,0 +1,43 @@
+import { HotkeyDefinition } from '../../controllers/hotkey.controller';
+import { ChipEvent } from '../../shared/chip-state.utils';
+import { GameComponent } from './GameComponent';
+export type ChipTablePosition = string;
+/**
+ * Shared base for games that use an event-sourced "chip table" betting model
+ * (e.g. Roulette, Baccarat).
+ *
+ * Responsibilities:
+ * - Per-click chip amount (1/2, 2x, reset)
+ * - Event-sourced chip state (add, multiplier-change)
+ * - Derived totals + syncing `gameData.betAmount`
+ * - Shared hotkeys for chip table interaction
+ */
+export declare abstract class ChipTableGameComponent extends GameComponent {
+    protected perClickAmount: string;
+    protected chipEvents: ChipEvent[];
+    /** Game-specific max payout check (uses derived state). */
+    protected abstract isMaxPayoutExceeded(chipEvents: ChipEvent[]): boolean;
+    protected get canUndo(): boolean;
+    protected firstUpdated(): void;
+    protected get canClear(): boolean;
+    protected get derivedChips(): Map<string, number>;
+    protected get totalBetAmount(): number;
+    protected get maxPerClickAmount(): string;
+    protected get isDoubleDisabled(): boolean;
+    watchDerivedChips(_prev?: unknown, _next?: unknown): void;
+    protected onBetAmountChange: (oldBetAmount: string, newBetAmount: string) => void;
+    protected adjustPerClickAmount(action: 'half' | 'double' | 'reset'): void;
+    protected handlePerClickAmountChange: (e: CustomEvent<{
+        amount: string;
+    }>) => void;
+    protected addChip(position: ChipTablePosition, inputAmount: string): void;
+    protected handleChipInteraction(position: ChipTablePosition, remove?: boolean): void;
+    protected handleUndo: () => void;
+    protected handleClear: () => void;
+    protected handleAdjustTotalBet: (action: "half" | "double") => void;
+    /**
+     * Return the set of hotkey definitions used for chip-table controls. Callbacks are used for manual & auto bet button elements, as `@query`
+     * elements are undefined within component constructors.
+     */
+    protected getChipTableHotkeys(getManualEl: () => HTMLElement | undefined, getAutoEl: () => HTMLElement | undefined): HotkeyDefinition[];
+}

package/dist/components/shared/DepositButton/DepositButton.d.ts

@@ -0,0 +1,9 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../context/game.context';
+export declare class DepositButton extends OrigamiElement {
+    betAboveBalance: boolean;
+    gameData?: gameContextType;
+    private handleDepositClick;
+    private shouldShowDepositButton;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Drawer/Drawer.d.ts

@@ -0,0 +1,45 @@
+import { CSSResultGroup } from 'lit';
+import { default as ShoelaceElement } from '../../../shared/origami-element.js';
+import { default as FocusTrap } from '../../../utils/focus-trap.js';
+export default class OrigamiDrawer extends ShoelaceElement {
+    static styles: CSSResultGroup;
+    private originalTrigger;
+    focusTrap: FocusTrap;
+    private closeWatcher;
+    private isDragging;
+    private startY;
+    private currentY;
+    private isCustomClosing;
+    private originalHeight;
+    drawer: HTMLElement;
+    panel: HTMLElement;
+    overlay: HTMLElement;
+    open: boolean;
+    label: string;
+    contained: boolean;
+    noHeader: boolean;
+    noCloseButton: boolean;
+    noFooter: boolean;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+    private requestClose;
+    private addOpenListeners;
+    private removeOpenListeners;
+    private handleDocumentKeyDown;
+    private handleTouchStart;
+    private handleTouchMove;
+    private handleTouchEnd;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private closeFromCurrentPosition;
+    private cleanupDragState;
+    private handlePanelWheel;
+    private handlePanelTouchStart;
+    private handlePanelTouchMove;
+    handleOpenChange(): Promise<void>;
+    handleNoModalChange(): void;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Drawer/Drawer.styles.d.ts

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

package/dist/components/shared/FairnessDetails/FairnessContent.d.ts

@@ -0,0 +1,47 @@
+import { LitElement } from 'lit';
+import { VerifierGameOptions } from '../../../shared/provably-fair-verifier';
+export interface ProvablyFairData {
+    publicKey: string;
+    request: string;
+    proof: string;
+    randomness: string;
+    clientSeed: string;
+    verifierOptions?: VerifierGameOptions;
+}
+export declare class FairnessContent extends LitElement {
+    static styles: import('lit').CSSResult[];
+    provablyFairData: ProvablyFairData;
+    showExtendedFields: boolean;
+    showClientSeedEditor: boolean;
+    showBackButton: boolean;
+    private _copiedFields;
+    private _copyTimeouts;
+    baseUrl: string;
+    private activeClientSeed;
+    private _isLoadingClientSeed;
+    private _hasClientSeedChanged;
+    private newClientSeed;
+    private _isSavingClientSeed;
+    private authToken;
+    private _showProvablyFairInfo;
+    private _onAccordionClick;
+    private gameConsumer;
+    private _clientSeedChangedHandler;
+    private _previousHistoryController?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    private _setupHistoryController;
+    private _cleanupHistoryController;
+    changeClientSeed(): Promise<void>;
+    private _flashCopied;
+    private _handleCopy;
+    private _handleViewOutcomeClick;
+    triggerBack(): void;
+    private _renderClientSeedInfoMessage;
+    private _renderClientSeedInputs;
+    private get _resolvedPublicKey();
+    private _renderVerificationInputs;
+    render(): import('lit').TemplateResult<1>;
+    private _renderProvablyFairInfo;
+}

package/dist/components/shared/FairnessDetails/FairnessContent.styles.d.ts

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

package/dist/components/shared/FairnessDetails/FairnessDetails.d.ts

@@ -0,0 +1,14 @@
+import { LitElement } from 'lit';
+import { ProvablyFairData } from './FairnessContent';
+export type FairnessDetailsTab = 'Fairness' | 'History';
+export declare class FairnessDetails extends LitElement {
+    static styles: import('lit').CSSResult[];
+    private gameConsumer;
+    provablyFairData: ProvablyFairData;
+    activeTab: FairnessDetailsTab;
+    showExtendedFields: boolean;
+    showClientSeedEditor: boolean;
+    showBackButton: boolean;
+    private _renderTabContent;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/FairnessDetails/HistoryTable.d.ts

@@ -0,0 +1,28 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class HistoryTable extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    private _historyData;
+    private _isLoading;
+    private gameConsumer;
+    private betResultCache;
+    private _historyDataChangedHandler;
+    private _previousHistoryController?;
+    private _tableWrapper?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    willUpdate(changedProperties: Map<string | number | symbol, unknown>): void;
+    private _setupHistoryController;
+    private _cleanupHistoryController;
+    private _historyLoadedMoreHandler;
+    firstUpdated(): Promise<void>;
+    private _initializeFromCache;
+    private _refreshInBackground;
+    private loadHistoryData;
+    private _handleRowHover;
+    private _formatMonetaryAmount;
+    private _getCurrencyDisplay;
+    private _formatTimestamp;
+    private _calculateMultiplier;
+    private _calculatePayout;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/FairnessDetails/HistoryTable.styles.d.ts

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

package/dist/components/shared/Footer/Footer.d.ts

@@ -0,0 +1,20 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../context/game.context';
+export declare class Footer extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    gameData?: gameContextType;
+    showLogo: boolean;
+    showHistoryButton: boolean;
+    gameInfoOpen: boolean;
+    hotkeysOpen: boolean;
+    private isVolumeSliderOpen;
+    private get logoUrl();
+    private handleLobbyClick;
+    private handleVolumeClick;
+    private handleInstantBetClick;
+    private handleProvablyFairClick;
+    private handleGameInfoClick;
+    private handleHotkeysClick;
+    private handleVerifyClick;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Footer/Footer.styles.d.ts

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

package/dist/components/shared/GameComponent.d.ts

@@ -0,0 +1,77 @@
+import { AutobetToggleEvent } from '../../shared/event-map';
+import { default as OrigamiElement } from '../../shared/origami-element';
+import { BetMode } from './GameSidebar/GameSidebar';
+import { AutobetEventPayload } from './GenericAutobet/GenericAutobet';
+import { default as Big } from 'big.js';
+import { NewBetItem } from '../../controllers/history.controller';
+export declare const isBetMode: (value: unknown) => value is BetMode;
+export type AutobetSettingsWithId = AutobetEventPayload & {
+    autobetId: string;
+    betIndex: number;
+    pnlSinceStart: string;
+};
+export interface GameBetResult {
+    pnl: Big;
+    gameOutcome: 'Win' | 'Loss' | 'Draw';
+    hasError: boolean;
+    errorMessage?: string;
+}
+export 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 deferredBetReset;
+    private gameConsumer;
+    get gameData(): import('./context/game.context').gameContextType;
+    get isDemoMode(): boolean;
+    get isToggleDisabled(): boolean;
+    get areInputsDisabled(): boolean;
+    /**
+     * Instant bets settle in a single step, with no reveal animation to cover the wait on the provider.
+     * Read live rather than pinned for the round: the animators decide the same way, several of them
+     * straight from the context, and a reveal they skip is one the round would wait on for good.
+     */
+    protected get isInstantBet(): boolean;
+    protected getDelay(normalDelay: number): number;
+    protected forceUIUpdate(): Promise<void>;
+    protected executeInstantOrAnimated<T>(instantOperation: () => Promise<T> | T, animatedOperation: () => Promise<T> | T): Promise<T>;
+    /**
+     * Clears the previous round so the next one starts from a blank board. An instant bet has no reveal
+     * animation to fill the wait on the provider, so the reset is held back until the response lands and
+     * the previous result stays up instead of the board sitting empty for the length of the request.
+     */
+    protected resetForNextBet(reset: () => void): void;
+    /**
+     * Places a bet, applying any reset held back by resetForNextBet once the provider has responded and
+     * before the round's result is applied.
+     */
+    protected placeBet<T>(request: () => Promise<T>): Promise<T>;
+    /**
+     * Drops the stake from the displayed balance so it moves as the reveal animation starts. An instant
+     * bet settles in one step, so the balance is left alone rather than dipping for however long the
+     * provider takes to respond and then jumping to the settled value.
+     */
+    protected preDeductStake(balanceBeforeBet: Big, stake: Big.BigSource): void;
+    /**
+     * Lets an animated reveal settle before the result counts as shown, since the outcome lands a beat
+     * after the cards or tiles come to rest and a win takes a beat longer again to register.
+     */
+    protected awaitRevealSettle(hasWon: boolean): Promise<void>;
+    /**
+     * Holds the round's result on screen long enough to be read before the next round replaces it. The
+     * hold runs from the point the result is painted rather than from the start of the round, so the wait
+     * on the provider does not eat into it the way a round wide budget does once latency is real.
+     */
+    protected holdResultDisplay(): 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): boolean;
+    protected updateHistoryWithBet(betResult: NewBetItem): void;
+    protected showError(message: string): void;
+    protected playWinFeedback(): void;
+}

package/dist/components/shared/GameInfo/GameInfoModal.d.ts

@@ -0,0 +1,16 @@
+import { LitElement, TemplateResult } from 'lit';
+import { gameContextType } from '../context/game.context';
+import { OrigamiGame } from '../../../shared/constants';
+export declare class GameInfoModal extends LitElement {
+    static styles: import('lit').CSSResult[];
+    gameData?: gameContextType;
+    gameType: OrigamiGame;
+    get rtpValue(): number;
+    get isDemoMode(): boolean;
+    private renderAccordionSection;
+    private renderAccordionSectionWithCustomContent;
+    private renderAccordionSectionWithInterpolation;
+    private getOverviewText;
+    private renderAccordionSections;
+    render(): TemplateResult<1>;
+}

package/dist/components/shared/GameInfo/GameInfoModal.styles.d.ts

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

package/dist/components/shared/GameInfo/gameInfoConfig.d.ts

@@ -0,0 +1,27 @@
+import { TranslationKey } from '../../../translations';
+import { OrigamiGame } from '../../../shared/constants';
+import { gameContextType } from '../context/game.context';
+export interface TranslationInfo {
+    key: TranslationKey;
+    fallback: string;
+}
+interface GameInfoConfig {
+    overview: {
+        translation: TranslationInfo;
+    };
+    tutorial: {
+        translation: TranslationInfo;
+        steps: Array<TranslationInfo>;
+    };
+    strategy: TranslationInfo;
+    provablyFair: TranslationInfo;
+    rtp: {
+        translation: TranslationInfo;
+    };
+    limit: {
+        translation: TranslationInfo;
+    };
+}
+export declare const gameInfoConfigs: Partial<Record<OrigamiGame, GameInfoConfig>>;
+export declare const calculateMaxMultiplier: (game: OrigamiGame, edge: number, gameData?: gameContextType) => string;
+export {};

package/dist/components/shared/GameLayout/GameLayout.d.ts

@@ -0,0 +1,51 @@
+import { default as OrigamiElement } from '../../../shared/origami-element.js';
+import { gameContextType } from '../context/game.context';
+import { AlertManager } from '../AlertManager/AlertManager';
+import { OrigamiGame } from '../../../shared/constants';
+export declare class GameLayout extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    gameData?: gameContextType;
+    gameType: OrigamiGame;
+    showFooter: boolean;
+    alertManager: AlertManager;
+    private modalContent;
+    private modalNavigationStack;
+    private isModalTransitioning;
+    private pendingModalContent;
+    private modalTransitionTimeout?;
+    private resizeObserver?;
+    private modalSessionId;
+    private isNavigatingHistory;
+    private navigateToModal;
+    private historyHasNextPage;
+    private isLoadingMoreHistory;
+    private get gameFooterPosition();
+    get isDemoMode(): boolean;
+    private getCustomBackgroundUrl;
+    private getGameAreaCustomStyles;
+    private previousHistoryController?;
+    private onHistoryDataChanged;
+    firstUpdated(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private setModalContent;
+    willUpdate(changed: Map<string | number | symbol, unknown>): void;
+    private setupHistoryController;
+    private cleanupHistoryController;
+    private pushModalHistory;
+    private handlePopState;
+    private handleLoadMoreHistory;
+    private renderModalContent;
+    private renderIndependentVerificationLink;
+    private renderDesktopFooter;
+    private renderMobileFooter;
+    private triggerBetVerify;
+    private triggerFairnessBack;
+    private openFairnessHistory;
+    private openFairnessFromGameInfo;
+    private getModalLabel;
+    private openVerifyOutcomeModal;
+    private handleBetResultModalBack;
+    private handleModalClose;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/GameLayout/GameLayout.styles.d.ts

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

package/dist/components/shared/GameOutcomeDisplay/GameOutcomeDisplay.d.ts

@@ -0,0 +1,113 @@
+import { LitElement } from 'lit';
+import { RollType } from '../../advanced-dice/advanced-dice.types';
+import { OrigamiGame } from '../../../shared/constants';
+import { WheelRiskLevel, WheelSegments } from '../../wheel/wheel.constants';
+import { PlinkoRiskLevel, PlinkoRowCount } from '../../plinko/plinko.constants';
+import { DisplayedCard } from '../../baccarat/baccarat.types';
+import { BaccaratOutcome, BlackjackOutcome, Card, InsuranceOutcome, SideBetResults } from '@betorigami/game-calculations';
+import { BlitzCardDetail, BlitzGameOutcome } from '../../blitz/blitz.utils';
+export interface MinesData {
+    selectedTiles: number[];
+    mineLocations: number[];
+}
+export interface LimboData {
+    isWin: boolean;
+    betId: string;
+    resultMultiplier: number;
+    betTargetMultiplier: number;
+}
+export interface DiceData {
+    value: number;
+    min: number;
+    max: number;
+    step: number;
+    showDice: boolean;
+    disabled: boolean;
+    resultValue: number;
+    isWin: boolean;
+    isRollLower: boolean;
+}
+export interface KenoData {
+    selectedTiles: number[];
+    resultTiles: number[];
+    isPlaying: boolean;
+    gameOver: boolean;
+    popupShowing: boolean;
+}
+export interface DiamondsData {
+    result: number[];
+}
+export interface WheelData {
+    risk: WheelRiskLevel;
+    segments: WheelSegments;
+    resultSegment: number;
+    betId: string;
+}
+export interface PlinkoData {
+    multiplier: number;
+    rowCount: PlinkoRowCount;
+    index: number;
+    riskLevel: PlinkoRiskLevel;
+}
+export interface AdvancedDiceData {
+    resultValue: number;
+    rollType: RollType;
+    firstBoundsLower: number;
+    firstBoundsUpper: number;
+    secondBoundsLower?: number;
+    secondBoundsUpper?: number;
+    isWin: boolean;
+}
+export interface RouletteData {
+    hitNumber: number;
+}
+export interface BaccaratData {
+    playerCards: DisplayedCard[];
+    bankerCards: DisplayedCard[];
+    displayedWinner: BaccaratOutcome | null;
+}
+export interface BlackjackData {
+    dealerCards: Card[];
+    mainHandCards: Card[];
+    splitHandCards: Card[] | null;
+    mainHandOutcome: BlackjackOutcome | null;
+    splitHandOutcome: BlackjackOutcome | null;
+    sideBetResults: SideBetResults | null;
+    insuranceOutcome: InsuranceOutcome | null;
+}
+export interface BlitzData {
+    cardDetails: BlitzCardDetail[];
+    revealCardIndex: number;
+    gameOutcome: BlitzGameOutcome;
+}
+export declare class GameOutcomeDisplay extends LitElement {
+    static styles: import('lit').CSSResult[];
+    gameType: OrigamiGame | 'INVALID_GAME';
+    inBetResultModal: boolean;
+    minesData?: MinesData;
+    limboData?: LimboData;
+    diceData?: DiceData;
+    kenoData?: KenoData;
+    diamondsData?: DiamondsData;
+    wheelData?: WheelData;
+    plinkoData?: PlinkoData;
+    advancedDiceData?: AdvancedDiceData;
+    rouletteData?: RouletteData;
+    baccaratData?: BaccaratData;
+    blackjackData?: BlackjackData;
+    blitzData?: BlitzData;
+    enableAnimation: boolean;
+    persistResult: boolean;
+    private animatedLimboMultiplier;
+    private animatedDiceResult;
+    private animatedAdvancedDiceResult;
+    private animatedKenoResults;
+    private animatedMinesState;
+    private animatedDiamondAppeared;
+    private gameConsumer;
+    connectedCallback(): void;
+    updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    private animateKenoResults;
+    private animateDiamondColors;
+    render(): import('lit').TemplateResult<1> | undefined;
+}

package/dist/components/shared/GameOutcomeDisplay/GameOutcomeDisplay.styles.d.ts

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