@betorigami/games 2.10.1 → 2.11.0

package/dist/components/baccarat/BaccaratGame.d.ts

@@ -0,0 +1,40 @@
+import { ChipEvent } from '../../shared/chip-state.utils';
+import { AutobetToggleEvent } from '../../shared/event-map';
+import { AutobetSettingsWithId, GameBetResult } from '../shared/GameComponent';
+import { ChipTableGameComponent } from '../shared/ChipTableGameComponent';
+import { BaccaratApi } from './baccarat.api';
+import { MockBaccaratApi } from './baccarat.mock.api';
+export declare class BaccaratGame extends ChipTableGameComponent {
+    static styles: import('lit').CSSResult[];
+    private isManualPlaying;
+    private resultMultiplier;
+    private history;
+    private gameWinPopupShowing;
+    private betId;
+    private payout;
+    private instantModeForCurrentBet;
+    private slowRevealEnabled;
+    /** The current game round - passed to BaccaratContent for rendering */
+    private currentRound;
+    private _baccaratManualEl?;
+    private _baccaratAutoEl?;
+    constructor();
+    get baccaratApi(): BaccaratApi | MockBaccaratApi;
+    get isToggleDisabled(): boolean;
+    get areInputsDisabled(): boolean;
+    private get isSlowRevealActive();
+    protected isMaxPayoutExceeded(chipEvents: ChipEvent[]): boolean;
+    private handleGridClick;
+    private handleSlowRevealChange;
+    private resetRound;
+    onManualOrAutoChange(): void;
+    private addToHistory;
+    private onDealSound;
+    private onCardFlip;
+    private processBetResult;
+    private handleBetExecution;
+    toggleAutobet(event: AutobetToggleEvent): Promise<void>;
+    baccaratPlay(): Promise<void>;
+    protected executeAutobet(_autobetSettings: AutobetSettingsWithId, _currentBetAmount: string): Promise<GameBetResult>;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/baccarat/BaccaratGame.styles.d.ts

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

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

@@ -0,0 +1,19 @@
+import { StartBetResponse } from '../../shared/bet.types';
+import { Currency } from '../../shared/constants';
+import { Language } from '../../translations';
+export type BaccaratSelection = {
+    position: 'PLAYER' | 'BANKER' | 'TIE';
+    amount: string;
+};
+export type BaccaratStartArgs = {
+    language: Language;
+    currency: Currency;
+    amount: string;
+    selections: BaccaratSelection[];
+};
+export declare class BaccaratApi {
+    private authToken;
+    private baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: BaccaratStartArgs): Promise<StartBetResponse>;
+}

package/dist/components/baccarat/baccarat.constants.d.ts

@@ -0,0 +1,16 @@
+import { Suit } from '@betorigami/game-calculations';
+export declare const CARD_DEAL_TIMEOUT_MS = 2000;
+export declare const MAX_CARDS_PER_HAND = 3;
+export declare const MAX_HISTORY_ITEMS = 20;
+export declare const DEALING_COMPLETE_TIMEOUT_MS = 10000;
+export declare const RED_SUITS: (suit: Suit) => suit is "Diamonds" | "Hearts";
+export declare const BACCARAT_PAYOUT_MULTIPLIERS: {
+    readonly PLAYER: 2;
+    readonly BANKER: 1.95;
+    readonly TIE: 8;
+};
+export interface BaccaratHistory {
+    multiplier: number;
+    won: boolean;
+    id: string;
+}

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

@@ -0,0 +1,8 @@
+import { BetResult } from '../../shared/bet.types';
+import { BaccaratStartArgs } from './baccarat.api';
+export declare class MockBaccaratApi {
+    startBet(data: BaccaratStartArgs): Promise<{
+        success: true;
+        data: BetResult;
+    }>;
+}

package/dist/components/baccarat/baccarat.types.d.ts

@@ -0,0 +1,17 @@
+import { BaccaratOutcome, Card } from '@betorigami/game-calculations';
+import { default as Big } from 'big.js';
+import { DisplayedCard as BaseDisplayedCard } from '../../shared/cards/card.types';
+/** Baccarat-specific card positions */
+export type BaccaratCardId = 'p-0-0' | 'p-0-1' | 'p-0-2' | 'b-0-0' | 'b-0-1' | 'b-0-2';
+/** Baccarat-specific DisplayedCard with typed ID */
+export type DisplayedCard = BaseDisplayedCard<BaccaratCardId>;
+export interface GameRound {
+    playerCards: Card[];
+    bankerCards: Card[];
+    winner: BaccaratOutcome;
+    playerValue: number;
+    bankerValue: number;
+    payout: Big;
+    multiplier: number;
+    betId: string;
+}

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

@@ -0,0 +1,20 @@
+import { default as Big } from 'big.js';
+import { BetResult, BaccaratEndAction } from '../../shared/bet.types';
+import { BaccaratCardId, DisplayedCard, GameRound } from './baccarat.types';
+import { BaccaratBetType, Card, Rank } from '@betorigami/game-calculations';
+export declare class BaccaratUtils {
+    static getCardValue(rank: Rank): number;
+    static valueOfHand(cards: Array<Card>): number;
+    static getMaxPossiblePayoutFromChips(chips: Map<string, number>): Big;
+    static createGameRound(responseData: BetResult, baccaratData: BaccaratEndAction): GameRound;
+    static buildSelectionsAndTotal(chips: Map<string, number>): {
+        selections: Array<{
+            position: BaccaratBetType;
+            amount: string;
+        }>;
+        totalAmount: Big;
+    };
+    /** Computes hand value from only the dealt cards, returns null if no cards dealt */
+    static getDealtHandValue(cards: DisplayedCard[]): number | null;
+    static getCardId(hand: BaccaratBetType.PLAYER | BaccaratBetType.BANKER, index: number): BaccaratCardId;
+}

package/dist/components/baccarat/baccarat.utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/blackjack/BlackjackContent/BlackjackContent.d.ts

@@ -0,0 +1,49 @@
+import { BlackjackOutcome, Card, InsuranceOutcome, SideBetResults } from '@betorigami/game-calculations';
+import { PropertyValues } from 'lit';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { UIDealerCard } from '../blackjack.helpers';
+export declare class BlackjackContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    isDesktop: boolean;
+    isPlaying: boolean;
+    history: Array<{
+        multiplier: number;
+        won: boolean;
+        id: string;
+    }>;
+    dealerCards: UIDealerCard[];
+    playerHands: Card[][];
+    activeHandIndex: number;
+    suppressNextAnimations: boolean;
+    isPlayerTurn: boolean;
+    instantMode: boolean;
+    outcomeDisplay: boolean;
+    mainHandOutcome: BlackjackOutcome | null;
+    splitHandOutcome: BlackjackOutcome | null;
+    sideBetResults: SideBetResults | null;
+    insuranceOutcome: InsuranceOutcome | null;
+    cardBackImageUrl: string | null;
+    private revealedIds;
+    private displayedMainHandOutcome;
+    private displayedSplitHandOutcome;
+    private allCards?;
+    private cardStack?;
+    private prevDealerCards;
+    private prevPlayerHands;
+    private get resolvedMainHandOutcome();
+    private get resolvedSplitHandOutcome();
+    private syncDisplayedOutcomes;
+    private getCardById;
+    protected updated(changedProps: PropertyValues): void;
+    private processCardChanges;
+    private processInstant;
+    private processAnimated;
+    private animateCardDeal;
+    private animateCardReveal;
+    private getRowTransform;
+    render(): import('lit').TemplateResult<1>;
+    private renderOutcomeDisplay;
+    private renderGameContent;
+    private shouldShowBlackjackPayoutPill;
+    private renderMainHandSecondaryPills;
+}

package/dist/components/blackjack/BlackjackContent/BlackjackContent.styles.d.ts

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

package/dist/components/blackjack/BlackjackControls/BlackjackControls.styles.d.ts

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

package/dist/components/blackjack/BlackjackControls/BlackjackManual.d.ts

@@ -0,0 +1,30 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class BlackjackManual extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    isPlaying: boolean;
+    betDisabled: boolean;
+    inputsDisabled: boolean;
+    isGameActive: boolean;
+    canHit: boolean;
+    canStand: boolean;
+    canSplit: boolean;
+    canDouble: boolean;
+    canBuyInsurance: boolean;
+    showInsurance: boolean;
+    insuranceAmount: string;
+    insuranceUnavailable: boolean;
+    showSideBets: boolean;
+    loadingAction: string | null;
+    pairBonusAmount: string;
+    threeCardBonusAmount: string;
+    gameData: gameContextType;
+    private isBetAmountValid;
+    private _betAboveBalance;
+    private actionButtonEl?;
+    triggerPrimaryAction(): void;
+    isPrimaryActionDisabled(): boolean;
+    private buyInsuranceLabel;
+    private renderBuyInsuranceButton;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/blackjack/BlackjackGame.d.ts

@@ -0,0 +1,89 @@
+import { BlackjackActionType, Card, BlackjackState, SideBetResults } from '@betorigami/game-calculations';
+import { BetResult } from '../../shared/bet.types';
+import { AutobetSettingsWithId, GameBetResult, GameComponent } from '../shared/GameComponent';
+import { BlackjackVisibleState, UIDealerCard } from './blackjack.helpers';
+import { IBlackjackApi } from './blackjack.api';
+export declare class BlackjackGame extends GameComponent {
+    static styles: import('lit').CSSResult[];
+    canonicalState: BlackjackState | null;
+    visibleState: BlackjackVisibleState;
+    private history;
+    controlsLocked: boolean;
+    private _loadingAction;
+    suppressNextContentAnimations: boolean;
+    sideBetMode: boolean;
+    pairBonusAmount: string;
+    threeCardBonusAmount: string;
+    sideBetResults: SideBetResults | null;
+    private showSideBetOnboarding;
+    insuranceAmount: string;
+    currentBetId: string | null;
+    currentMainBetAmount: string;
+    private _blackjackManualEl?;
+    private readonly animationController;
+    private readonly actionHandlers;
+    private readonly betController;
+    private hasTrackedSessionConfig;
+    private previousAuthToken;
+    private previousBaseUrl;
+    get activeHand(): Card[];
+    get playerHandsForContent(): Card[][];
+    get activeHandIndexForContent(): number;
+    get isGameActive(): boolean;
+    get isToggleDisabled(): boolean;
+    get areInputsDisabled(): boolean;
+    private get totalBetExceedsBalance();
+    private get sidebarMode();
+    private readonly _getBlackjackApi;
+    getBlackjackApi(): IBlackjackApi;
+    constructor();
+    setCanonicalState(state: BlackjackState | null): void;
+    setVisibleState(state: BlackjackVisibleState): void;
+    updateVisibleState(partial: Partial<BlackjackVisibleState>): void;
+    private addToHistory;
+    withOptimisticBalanceDeduction<T>(deductionAmount: string, action: () => Promise<T>): Promise<T>;
+    private runWithLockedControls;
+    firstUpdated(changedProperties: Map<string | number | symbol, unknown>): Promise<void>;
+    protected updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    getBlackjackActiveBet(): Promise<void>;
+    addPlayerCardToHand(handIndex: number, card: Card): string;
+    addDealerCard(card: UIDealerCard): string;
+    updateDealerCard(index: number, card: UIDealerCard, faceDown: boolean): void;
+    setSuppressAnimations(value: boolean): void;
+    setSideBetResults(value: SideBetResults | null): void;
+    revertToStandardModeIfNoSideBets(): void;
+    finishRound(betData: BetResult): Promise<void>;
+    executeNextAction(type: BlackjackActionType): Promise<BetResult | null>;
+    blackjackPlay(): Promise<void>;
+    protected executeAutobet(_autobetSettings: AutobetSettingsWithId, _currentBetAmount: string): Promise<GameBetResult>;
+    triggerForceUIUpdate(): Promise<void>;
+    triggerShowError(error: string): void;
+    setHasPendingBet(value: boolean): void;
+    private get insuranceUnavailable();
+    private canAffordAction;
+    private canPerformAction;
+    private onBuyInsurance;
+    private onDeclineInsurance;
+    private handleHit;
+    private handleStand;
+    private handleDoubleDown;
+    private handleSplit;
+    private isSpacebarDisabled;
+    private isHitDisabled;
+    private isStandDisabled;
+    private isSplitDisabled;
+    private isDoubleDisabled;
+    private isAcceptInsuranceDisabled;
+    private isNoInsuranceDisabled;
+    private handleAcceptInsurance;
+    private handleNoInsurance;
+    private handleSpacebar;
+    private onBetModeChange;
+    private get sideBetOnboardingComplete();
+    private handleSideBetOnboardingComplete;
+    private onPairBonusAmountChange;
+    private onThreeCardBonusAmountChange;
+    private onDealSound;
+    private onCardFlip;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/blackjack/BlackjackGame.styles.d.ts

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

package/dist/components/blackjack/BlackjackSideBetOnboarding/BlackjackSideBetOnboarding.d.ts

@@ -0,0 +1,16 @@
+import { PropertyValues } from 'lit';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class BlackjackSideBetOnboarding extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    private gameData?;
+    private _step;
+    private _revealedCount;
+    private _revealTimeouts;
+    protected willUpdate(changed: PropertyValues): void;
+    private _clearRevealTimeouts;
+    disconnectedCallback(): void;
+    private _advance;
+    private _renderCards;
+    private _renderDemo;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/blackjack/BlackjackSideBetOnboarding/BlackjackSideBetOnboarding.styles.d.ts

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

package/dist/components/blackjack/actions/betController.d.ts

@@ -0,0 +1,20 @@
+import { BlackjackState } from '@betorigami/game-calculations';
+import { BetResult } from '../../../shared/bet.types';
+import { BlackjackGame } from '../BlackjackGame';
+import { CardAnimationController } from '../controllers/CardAnimationController';
+type BlackjackBetExecutionResult = {
+    success: true;
+    bjState: BlackjackState;
+    betData: BetResult;
+} | {
+    success: false;
+    error: string;
+};
+export declare class BetController {
+    private readonly game;
+    private readonly animator;
+    constructor(game: BlackjackGame, animator: CardAnimationController);
+    executeBet(amount: string): Promise<BlackjackBetExecutionResult>;
+    handleBetExecution(amount: string): Promise<void>;
+}
+export {};

package/dist/components/blackjack/actions/gameActionHandlers.d.ts

@@ -0,0 +1,18 @@
+import { BlackjackActionType } from '@betorigami/game-calculations';
+import { BlackjackGame } from '../BlackjackGame';
+import { CardAnimationController } from '../controllers/CardAnimationController';
+export declare class GameActionHandlers {
+    private readonly game;
+    private readonly animator;
+    constructor(game: BlackjackGame, animator: CardAnimationController);
+    handleHit(currentBetId: string | null): Promise<void>;
+    handleStand(currentBetId: string | null): Promise<void>;
+    handleDoubleDown(currentBetId: string | null): Promise<void>;
+    handleSplit(currentBetId: string | null): Promise<void>;
+    handleInsurance(type: BlackjackActionType.BUY_INSURANCE | BlackjackActionType.REJECT_INSURANCE): Promise<void>;
+    private handleSplitCardAction;
+    private handleSplitStandAction;
+    private updateVisibleSplitHands;
+    private moveToSplitHand;
+    private waitForLatestSplitCard;
+}

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

@@ -0,0 +1,37 @@
+import { BlackjackActionType } from '@betorigami/game-calculations';
+import { BetResult } from '../../shared/bet.types';
+import { ErrorBetResult } from '../../shared/provider-api/bet-result';
+export type BlackjackStartArgs = {
+    mainBetAmount: string;
+    pairBonusAmount?: string;
+    threeCardBonusAmount?: string;
+};
+export type BlackjackNextArgs = {
+    betId: string;
+    type: BlackjackActionType;
+};
+export type BlackjackStartResult = {
+    success: true;
+    data: BetResult;
+} | ErrorBetResult;
+export type BlackjackNextResult = {
+    success: true;
+    data: BetResult;
+} | ErrorBetResult;
+export type BlackjackGetActiveBetResult = {
+    success: true;
+    data: BetResult | null;
+} | ErrorBetResult;
+export interface IBlackjackApi {
+    startBet(data: BlackjackStartArgs): Promise<BlackjackStartResult>;
+    next(data: BlackjackNextArgs): Promise<BlackjackNextResult>;
+    getActiveBet(): Promise<BlackjackGetActiveBetResult>;
+}
+export declare class BlackjackApi implements IBlackjackApi {
+    private readonly authToken;
+    private readonly baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: BlackjackStartArgs): Promise<BlackjackStartResult>;
+    next(data: BlackjackNextArgs): Promise<BlackjackNextResult>;
+    getActiveBet(): Promise<BlackjackGetActiveBetResult>;
+}

package/dist/components/blackjack/blackjack.helpers.d.ts

@@ -0,0 +1,45 @@
+import { BlackjackActionType, BlackjackOutcome, InsuranceOutcome, BlackjackHandDto, BlackjackState, Card, SideBetResults } from '@betorigami/game-calculations';
+import { BetResult } from '../../shared/bet.types';
+export interface BlackjackHistory {
+    multiplier: number;
+    won: boolean;
+    id: string;
+}
+export type UIDealerCard = Card & {
+    faceDown?: boolean;
+};
+export declare const mapCardToUI: (card: {
+    rank: string;
+    suit: string;
+}) => Card;
+type BJSplitState = Extract<BlackjackState, {
+    mainHand: BlackjackHandDto;
+    splitHand: BlackjackHandDto;
+}>;
+export declare const isSplitState: (state: BlackjackState) => state is BJSplitState;
+export type BlackjackVisibleState = {
+    stage: 'idle' | 'dealing' | 'insurance' | 'player' | 'dealer' | 'settled';
+    dealerCards: UIDealerCard[];
+    playerHands: Card[][];
+    activeHandIndex: number;
+    resultMultiplier: number | null;
+    mainHandOutcome: BlackjackOutcome | null;
+    splitHandOutcome: BlackjackOutcome | null;
+    insuranceOutcome: InsuranceOutcome | null;
+    isActing: boolean;
+};
+export declare const createInitialVisibleState: () => BlackjackVisibleState;
+export declare const extractBlackjackState: (bet: BetResult) => BlackjackState | null;
+export declare const deriveValidActions: (state: BlackjackState | null) => readonly BlackjackActionType[];
+export declare const deriveStage: (state: BlackjackState) => BlackjackVisibleState["stage"];
+export declare const deriveOutcomes: (state: BlackjackState | null) => {
+    mainOutcome: BlackjackOutcome | null;
+    splitOutcome: BlackjackOutcome | null;
+};
+export declare const deriveInsuranceOutcome: (state: BlackjackState | null) => InsuranceOutcome | null;
+export declare const deriveSideBetResults: (state: BlackjackState | null) => SideBetResults | null;
+export declare const deriveDealerCards: (state: BlackjackState) => UIDealerCard[];
+export declare const derivePlayerHands: (state: BlackjackState) => Card[][];
+export declare const deriveFullVisibleState: (state: BlackjackState) => BlackjackVisibleState;
+export declare const isInsuranceUnavailable: (insuranceAmount: string, minBet: number | null) => boolean;
+export {};

package/dist/components/blackjack/blackjack.icons.d.ts

@@ -0,0 +1,4 @@
+export declare const hitIcon: import('lit').TemplateResult<2>;
+export declare const standIcon: import('lit').TemplateResult<2>;
+export declare const splitIcon: import('lit').TemplateResult<2>;
+export declare const doubleIcon: import('lit').TemplateResult<2>;

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

@@ -0,0 +1,22 @@
+import { PlayResult } from '@betorigami/game-calculations';
+import { Action } from '../../shared/bet.types';
+import { MockBridgedGameService, GameEngine } from '../../shared/mock-bridged-game-service';
+import { BlackjackStartArgs, BlackjackNextArgs, IBlackjackApi, BlackjackStartResult, BlackjackNextResult, BlackjackGetActiveBetResult } from './blackjack.api';
+export declare class MockBlackjackApi extends MockBridgedGameService implements IBlackjackApi {
+    private static pendingCardSequence;
+    protected readonly gameId = "blackjack";
+    protected readonly maxRandomValues = 63;
+    protected readonly minRandomValue = 0;
+    protected readonly maxRandomValue = 51;
+    protected readonly edge = 1;
+    private mainBetAmount;
+    static setCardSequence(cards: number[]): void;
+    constructor(initialBalance: number);
+    protected createGameEngine(edge: number): GameEngine;
+    protected toActionData(playResult: PlayResult): Action['data'];
+    private get insuranceAmount();
+    private getBetWithInsuranceAmount;
+    startBet(data: BlackjackStartArgs): Promise<BlackjackStartResult>;
+    next(data: BlackjackNextArgs): Promise<BlackjackNextResult>;
+    getActiveBet(): Promise<BlackjackGetActiveBetResult>;
+}

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

@@ -0,0 +1,18 @@
+import { BlackjackOutcome, Rank } from '@betorigami/game-calculations';
+type PillClassParams = {
+    outcome: BlackjackOutcome | null;
+    isPlayerTurn: boolean;
+    handIndex: number;
+    activeHandIndex: number;
+    handCount: number;
+};
+export declare const handBestValue: (cards: ReadonlyArray<{
+    rank: Rank;
+}>) => number;
+export declare const handDisplayValue: (cards: ReadonlyArray<{
+    rank: Rank;
+}>) => string;
+export declare const getCardClassFromOutcome: (outcome: BlackjackOutcome | null) => string;
+export declare const getOutcomePillClass: (outcome: BlackjackOutcome | null) => string;
+export declare const getPillClass: ({ outcome, isPlayerTurn, handIndex, activeHandIndex, handCount }: PillClassParams) => string;
+export {};

package/dist/components/blackjack/blackjack.utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/blackjack/controllers/CardAnimationController.d.ts

@@ -0,0 +1,36 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+import { BlackjackVisibleState, UIDealerCard } from '../blackjack.helpers';
+import { Card } from '@betorigami/game-calculations';
+export type CardAnimationHost = EventTarget & {
+    gameData: {
+        instantBetEnabled: boolean;
+    };
+    visibleState: {
+        dealerCards: UIDealerCard[];
+        stage: BlackjackVisibleState['stage'];
+    };
+    addPlayerCardToHand(handIndex: number, card: Card): string;
+    addDealerCard(card: UIDealerCard): string;
+    updateVisibleState(partial: Partial<BlackjackVisibleState>): void;
+    updateDealerCard(index: number, card: UIDealerCard, faceDown: boolean): void;
+    triggerForceUIUpdate(): Promise<void>;
+};
+export declare class CardAnimationController implements ReactiveController {
+    private readonly host;
+    constructor(host: ReactiveControllerHost & CardAnimationHost);
+    hostConnected(): void;
+    private get instantMode();
+    private static readonly BETWEEN_CARD_ACTIONS_PAUSE;
+    private static readonly DEALER_REVEAL_PAUSE;
+    private waitBeforeDealerReveal;
+    private waitBetweenCardActions;
+    private dealPlayerCard;
+    private dealDealerCard;
+    private revealDealerHoleCard;
+    private runCardActions;
+    playInitialDeal(playerCards: Card[], dealerCards: UIDealerCard[]): Promise<void>;
+    playDealerReveal(dealerCards: UIDealerCard[]): Promise<void>;
+    playSplitDeal(mainHandSecondCard: Card, splitHandSecondCard: Card): Promise<void>;
+    waitForAllCardsToBeIdle(): Promise<void>;
+    waitForCardDealComplete(cardId: string): Promise<void>;
+}

package/dist/components/blitz/BlitzContent/BlitzCard.d.ts

@@ -0,0 +1,9 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { BlitzCardDetail, BlitzGameOutcome } from '../blitz.utils';
+export declare class BlitzCard extends OrigamiElement {
+    card: BlitzCardDetail;
+    hitCount: number;
+    gameOutcome: BlitzGameOutcome;
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/blitz/BlitzContent/BlitzCard.styles.d.ts

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

package/dist/components/blitz/BlitzContent/BlitzCardContainer.d.ts

@@ -0,0 +1,19 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { BlitzCardDetail, BlitzGameOutcome } from '../blitz.utils';
+export declare class BlitzCardContainer extends OrigamiElement {
+    cardDetails: BlitzCardDetail[];
+    revealCardIndex: number;
+    progressActive: boolean;
+    progressDurationMs: number;
+    gameOutcome: BlitzGameOutcome;
+    popupShowing: boolean;
+    outcomeDisplay: boolean;
+    static styles: import('lit').CSSResult[];
+    private get revealedCount();
+    private get revealedCardCounts();
+    private get progressScale();
+    private get progressTargetScale();
+    private get isProgressing();
+    render(): import('lit').TemplateResult<1>;
+    private handleProgressAnimationEnd;
+}

package/dist/components/blitz/BlitzContent/BlitzCardContainer.styles.d.ts

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

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

@@ -0,0 +1,13 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { BlitzCardDetail, BlitzGameOutcome } from '../blitz.utils';
+export declare class BlitzContent extends OrigamiElement {
+    cardDetails: BlitzCardDetail[];
+    revealCardIndex: number;
+    progressActive: boolean;
+    progressDurationMs: number;
+    gameOutcome: BlitzGameOutcome;
+    popupShowing: boolean;
+    outcomeDisplay: boolean;
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<1>;
+}

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

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

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

@@ -0,0 +1,23 @@
+import { Currency } from '../../../shared/constants';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { Language } from '../../../translations';
+export declare class BlitzAuto extends OrigamiElement {
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    betDisabled: boolean;
+    isDesktop: boolean;
+    betMaxMultiplier: number;
+    picks: number;
+    minPicks: number;
+    maxPicks: number;
+    edge: number;
+    profitOnWin: string;
+    language: Language;
+    currency: Currency;
+    private genericAutobetEl?;
+    static styles: import('lit').CSSResult[];
+    triggerPrimaryAction(): void;
+    isPrimaryActionDisabled(): boolean;
+    render(): import('lit').TemplateResult<1>;
+}

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

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