@betorigami/games 2.10.1 → 2.11.0

package/dist/components/advanced-dice/AdvancedDiceContent/AdvancedDiceContent.d.ts

@@ -0,0 +1,24 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { AdvancedDiceHistory, RollType, Bounds } from '../advanced-dice.types';
+export declare class AdvancedDiceContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    isPlaying: boolean;
+    showDice: boolean;
+    isWin: boolean;
+    edge: number;
+    resultValue: number | null;
+    history: AdvancedDiceHistory[];
+    isDesktop: boolean;
+    rollType: RollType;
+    bounds: Bounds;
+    secondBounds: Bounds;
+    private handleBoundsChange;
+    private handleMultiplierInputChange;
+    private handleWinChanceInputChange;
+    private handleBoundsInputValidityChange;
+    /**
+     * Convert internal bounds (0-10000) to display scale (0-100) for the slider.
+     */
+    private get sliderPositions();
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/advanced-dice/AdvancedDiceContent/AdvancedDiceContent.styles.d.ts

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

package/dist/components/advanced-dice/AdvancedDiceContentBottom/AdvancedDiceContentBottom.d.ts

@@ -0,0 +1,55 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { SupportedEdgePercentages } from '../../../shared/constants';
+import { RollType, Bounds } from '../advanced-dice.types';
+export declare class AdvancedDiceContentBottom extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    rollType: RollType;
+    bounds: Bounds;
+    secondBounds: Bounds;
+    disabled: boolean;
+    gameData?: gameContextType;
+    private _winChanceInputValue;
+    private _multiplierInputValue;
+    private _winChanceFocused;
+    private _multiplierFocused;
+    private _previousMultiplierInputValue;
+    private _previousWinChanceInputValue;
+    private _lowerBoundInputValue;
+    private _upperBoundInputValue;
+    private _secondLowerBoundInputValue;
+    private _secondUpperBoundInputValue;
+    private _lowerBoundFocused;
+    private _upperBoundFocused;
+    private _secondLowerBoundFocused;
+    private _secondUpperBoundFocused;
+    get edge(): SupportedEdgePercentages;
+    private get minMultiplier();
+    private get strategy();
+    set winChanceInputValue(value: string);
+    set multiplierInputValue(value: string);
+    private calculateWinChance;
+    private calculateMultiplier;
+    private isValidMultiplier;
+    private isValidWinChance;
+    private setWinChanceValue;
+    private setMultiplierValue;
+    boundsChangeHandler(): void;
+    private setKnobValue;
+    private setLowerBoundValue;
+    private setUpperBoundValue;
+    private setSecondLowerBoundValue;
+    private setSecondUpperBoundValue;
+    private validateKnobValue;
+    private checkAndEmitBoundsValidity;
+    private getLowerBoundError;
+    private getUpperBoundError;
+    private getSecondLowerBoundError;
+    private getSecondUpperBoundError;
+    private renderMultiplierInput;
+    private renderWinChanceInput;
+    private renderTwoKnobInputs;
+    private renderFourKnobInputs;
+    private renderBoundsInputs;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/advanced-dice/AdvancedDiceContentBottom/AdvancedDiceContentBottom.styles.d.ts

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

package/dist/components/advanced-dice/AdvancedDiceControls/AdvancedDiceAuto.d.ts

@@ -0,0 +1,15 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { RollType } from '../advanced-dice.types';
+export declare class AdvancedDiceAuto extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    betDisabled: boolean;
+    isDesktop: boolean;
+    betMaxMultiplier: number;
+    rollType: RollType;
+    gameData?: gameContextType;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/advanced-dice/AdvancedDiceControls/AdvancedDiceControls.styles.d.ts

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

package/dist/components/advanced-dice/AdvancedDiceControls/AdvancedDiceManual.d.ts

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

package/dist/components/advanced-dice/AdvancedDiceGame.d.ts

@@ -0,0 +1,41 @@
+import { AutobetSettingsWithId, GameBetResult, GameComponent } from '../shared/GameComponent';
+import { MockAdvancedDiceApi } from './advanced-dice.mock.api';
+import { AdvancedDiceApi } from './advanced-dice.api';
+export declare class AdvancedDiceGame extends GameComponent {
+    static styles: import('lit').CSSResult[];
+    private isManualPlaying;
+    private showDice;
+    private isWin;
+    private resultValue;
+    private history;
+    private rollType;
+    private bounds;
+    private secondBounds;
+    private _multiplierInputValid;
+    private _winChanceInputValid;
+    private _boundsInputValid;
+    private _diceManualEl?;
+    private _diceAutoEl?;
+    get isToggleDisabled(): boolean;
+    get areInputsDisabled(): boolean;
+    /** Roll type cycle order for hotkey */
+    private static readonly ROLL_TYPE_ORDER;
+    constructor();
+    /** Cycles through roll types: Inside → Outside → Between → Inside */
+    private cycleRollType;
+    get advancedDiceApi(): AdvancedDiceApi | MockAdvancedDiceApi;
+    private buildGameInputs;
+    private calculateWinChance;
+    private calculateMultiplier;
+    private isValidWinChance;
+    dicePlay(): Promise<void>;
+    private handleBetExecution;
+    addToHistory(multiplier: number, won: boolean, id: string): void;
+    protected executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
+    private handleRollTypeChange;
+    private handleBoundsChange;
+    private handleMultiplierInputChange;
+    private handleWinChanceInputChange;
+    private handleBoundsInputValidityChange;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/advanced-dice/AdvancedDiceGame.styles.d.ts

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

package/dist/components/advanced-dice/AdvancedDiceSlider/AdvancedDiceSlider.d.ts

@@ -0,0 +1,30 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { RollType } from '../advanced-dice.types';
+export declare class AdvancedDiceSlider extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    disabled: boolean;
+    resultValue: number | null;
+    showDice: boolean;
+    isWin: boolean;
+    inGameDisplay: boolean;
+    persistResult: boolean;
+    ignoreInstantBet: boolean;
+    rollType: RollType;
+    firstBoundsLower: number;
+    firstBoundsUpper: number;
+    secondBoundsLower: number;
+    secondBoundsUpper: number;
+    gameData?: gameContextType;
+    private get edge();
+    private get strategy();
+    private isResultVisible;
+    private fadeOutTimer?;
+    private lastStepValue;
+    private lastStepFeedbackTime;
+    disconnectedCallback(): void;
+    updated(changedProperties: Map<string, unknown>): void;
+    private handleKnobChange;
+    private playKnobStepFeedback;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/advanced-dice/AdvancedDiceSlider/AdvancedDiceSlider.styles.d.ts

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

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

@@ -0,0 +1,14 @@
+import { BaseStartArgs, StartBetResponse } from '../../shared/bet.types';
+import { Language } from '../../translations';
+import { AdvancedDiceInputs } from './advanced-dice.types';
+export interface AdvancedDiceStartArgs extends BaseStartArgs {
+    language: Language;
+}
+export declare class AdvancedDiceApi {
+    private authToken;
+    private baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    startBet(data: AdvancedDiceStartArgs & {
+        gameInputs: AdvancedDiceInputs;
+    }): Promise<StartBetResponse>;
+}

package/dist/components/advanced-dice/advanced-dice.constants.d.ts

@@ -0,0 +1,59 @@
+import { Bounds, RollType } from './advanced-dice.types';
+import { Language } from '../../translations';
+export declare const getRollTypeOptions: (language: Language) => {
+    value: RollType;
+    label: string;
+}[];
+/**
+ * History entry for advanced dice game.
+ */
+export interface AdvancedDiceHistory {
+    multiplier: number;
+    won: boolean;
+    id: string;
+}
+/**
+ * Default bounds configuration for each roll type.
+ */
+export interface DefaultBoundsConfig {
+    bounds?: Bounds;
+    firstBounds?: Bounds;
+    secondBounds?: Bounds;
+}
+/**
+ * Default bounds for each roll type.
+ * Used when switching between roll types to reset to sensible defaults.
+ */
+export declare const DEFAULT_BOUNDS: Record<RollType, DefaultBoundsConfig>;
+/**
+ * Knob identifiers for the slider.
+ * For ROLL_BETWEEN and ROLL_OUTSIDE: only firstBoundsLower and firstBoundsUpper are used.
+ * For ROLL_BETWEEN_TWO: all four knobs are used.
+ */
+export declare const SLIDER_KNOB_IDS: readonly ["firstBoundsLower", "firstBoundsUpper", "secondBoundsLower", "secondBoundsUpper"];
+/** Input value precision for multiplier and win chance */
+export declare const INPUT_VALUE_PRECISION = 4;
+/**
+ * Divisor used in win chance calculations.
+ * Matches the backend's EFFECTIVE_RANGE (values 0-10000 inclusive = 10001 possible values).
+ */
+export declare const CALCULATION_DIVISOR = 10001;
+/** Maximum internal bound value (0-10000 scale) */
+export declare const MAX_INTERNAL_BOUND = 10000;
+/** Minimum internal bound value */
+export declare const MIN_INTERNAL_BOUND = 0;
+/** Precision for bound input values (display scale) */
+export declare const BOUND_INPUT_PRECISION = 2;
+/** Min bound value in display scale */
+export declare const MIN_BOUND_DISPLAY = 0;
+/** Max bound value in display scale (100 = 10000 internal) */
+export declare const MAX_BOUND_DISPLAY = 100;
+/** Minimum win chance percentage */
+export declare const MIN_WIN_CHANCE = 0.01;
+/**
+ * Get the minimum number of winning spots.
+ * This is edge-independent - always 1 to ensure player can win.
+ *
+ * @returns Minimum number of winning spots (always 1)
+ */
+export declare const MIN_WIN_RANGE = 1;

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

@@ -0,0 +1,13 @@
+import { BetResult } from '../../shared/bet.types';
+import { AdvancedDiceStartArgs } from './advanced-dice.api';
+import { AdvancedDiceInputs } from './advanced-dice.types';
+export declare class MockAdvancedDiceApi {
+    private readonly edge;
+    constructor(edge: number);
+    startBet(data: AdvancedDiceStartArgs & {
+        gameInputs: AdvancedDiceInputs;
+    }): Promise<{
+        success: true;
+        data: BetResult;
+    }>;
+}

package/dist/components/advanced-dice/advanced-dice.types.d.ts

@@ -0,0 +1,84 @@
+export type Bounds = {
+    lower: number;
+    upper: number;
+};
+export declare enum RollType {
+    ROLL_BETWEEN = "ROLL_BETWEEN",
+    ROLL_OUTSIDE = "ROLL_OUTSIDE",
+    ROLL_BETWEEN_TWO = "ROLL_BETWEEN_TWO"
+}
+/**
+ * History entry for advanced dice game.
+ */
+export interface AdvancedDiceHistory {
+    multiplier: number;
+    won: boolean;
+    id: string;
+}
+/**
+ * Default bounds configuration for each roll type.
+ */
+export interface DefaultBoundsConfig {
+    bounds?: Bounds;
+    firstBounds?: Bounds;
+    secondBounds?: Bounds;
+}
+export type RollBetween = {
+    mode: RollType.ROLL_BETWEEN;
+    bounds: Bounds;
+};
+export type RollOutside = {
+    mode: RollType.ROLL_OUTSIDE;
+    bounds: Bounds;
+};
+export type RollBetweenTwo = {
+    mode: RollType.ROLL_BETWEEN_TWO;
+    firstBounds: Bounds;
+    secondBounds: Bounds;
+};
+export type AdvancedDiceInputs = RollBetween | RollOutside | RollBetweenTwo;
+/**
+ * Data structure for bounds results.
+ */
+export interface BoundsData {
+    bounds: Bounds;
+    secondBounds?: Bounds;
+}
+/**
+ * Result of a bounds validation operation (discriminated union).
+ */
+export type BoundsValidationResult = {
+    readonly valid: true;
+} | {
+    readonly valid: false;
+    readonly error: string;
+};
+/**
+ * Result of a slider knob validation operation (discriminated union).
+ */
+export type SliderValidationResult = {
+    readonly valid: true;
+} | {
+    readonly valid: false;
+    readonly clampedValue: number;
+};
+/**
+ * Result of evaluating a game outcome.
+ */
+export interface OutcomeResult {
+    winChancePercent: number;
+    isWin: boolean;
+}
+/**
+ * Slider knob positions in display scale (0-100).
+ */
+export interface SliderPositions {
+    firstBoundsLower: number;
+    firstBoundsUpper: number;
+    secondBoundsLower: number;
+    secondBoundsUpper: number;
+}
+/**
+ * Knob identifiers for the slider.
+ */
+export type SliderKnobId = 'firstBoundsLower' | 'firstBoundsUpper' | 'secondBoundsLower' | 'secondBoundsUpper';

package/dist/components/advanced-dice/advanced-dice.utils.d.ts

@@ -0,0 +1,18 @@
+import { SliderPositions, Bounds } from './advanced-dice.types';
+export declare class AdvancedDiceUtils {
+    static isWithinBoundsInclusive(bounds: Bounds, result: number): boolean;
+    static getInclusiveBoundsRange(bounds: Bounds): number;
+    static isWithinBoundsExclusive(bounds: Bounds, result: number): boolean;
+    static getExclusiveBoundsRange(bounds: Bounds): number;
+    static calculateMultiplier(winChance: number, edge: number): string;
+    static getMinMultiplier(edge: number, minMultiplier: number | null): string;
+    static getMaxMultiplier(edge: number): string;
+    static getWinChanceFromMultiplier(multiplier: string, edge: number): number;
+    static getMultiplierFromWinChance(winChance: string, edge: number): string;
+    static isValidMultiplier(multiplier: string, edge: number, minMultiplier: number | null): boolean;
+    static isValidWinChance(winChance: string, edge: number, minMultiplier: number | null): boolean;
+    static boundToDisplayString(internalValue: number): string;
+    static boundsToSliderPositions(bounds: Bounds, secondBounds?: Bounds): SliderPositions;
+    static getMaxWinRange(edge: number, minMultiplier: number | null): number;
+    static getMaxWinChance(edge: number, minMultiplier: number | null): number;
+}

package/dist/components/advanced-dice/strategies/base-roll-type.strategy.d.ts

@@ -0,0 +1,30 @@
+import { BoundsData, BoundsValidationResult, SliderValidationResult, SliderPositions, SliderKnobId, OutcomeResult, RollType, Bounds } from '../advanced-dice.types';
+export declare abstract class BaseRollTypeStrategy {
+    abstract readonly rollType: RollType;
+    abstract readonly knobCount: 2 | 4;
+    abstract readonly hasSecondBounds: boolean;
+    abstract getMinKnobGap(edge: number, minMultiplier: number | null): number;
+    abstract getMaxKnobGap(edge: number, minMultiplier: number | null): number;
+    abstract calculateWinRange(bounds: Bounds, secondBounds?: Bounds): number;
+    abstract isWinningResult(bounds: Bounds, secondBounds: Bounds | undefined, result: number): boolean;
+    abstract scaleBoundsForWinChance(currentBounds: Bounds, currentSecondBounds: Bounds | undefined, newWinChance: number, edge: number, minMultiplier: number | null): BoundsData;
+    calculateWinChance(bounds: Bounds, secondBounds?: Bounds): number;
+    evaluateOutcome(bounds: Bounds, secondBounds: Bounds | undefined, result: number): OutcomeResult;
+    validateBounds(bounds: Bounds, secondBounds: Bounds | undefined, edge: number, minMultiplier: number | null): BoundsValidationResult;
+    validateKnobInput(currentBounds: Bounds, currentSecondBounds: Bounds | undefined, knobId: SliderKnobId, newValueDisplay: number, edge: number, minMultiplier: number | null): BoundsValidationResult;
+    protected buildProposedBounds(currentBounds: Bounds, _currentSecondBounds: Bounds | undefined, knobId: SliderKnobId, newValueInternal: number): BoundsData;
+    validateSliderKnobMove(knobId: SliderKnobId, newValue: number, currentPositions: SliderPositions, edge: number, minMultiplier: number | null): SliderValidationResult;
+    protected getKnobAllowedRange(knobId: SliderKnobId, currentPositions: SliderPositions, edge: number, minMultiplier: number | null): {
+        min: number;
+        max: number;
+    };
+    sliderPositionsToBounds(positions: SliderPositions): BoundsData;
+    boundsToSliderPositions(bounds: Bounds, secondBounds?: Bounds): SliderPositions;
+    getBoundsFromKnobChange(currentBounds: Bounds, _currentSecondBounds: Bounds | undefined, knobId: SliderKnobId, newValueDisplay: number, edge: number, minMultiplier: number | null): BoundsData;
+    protected clampBounds(lower: number, upper: number): Bounds;
+    protected enforceMinGap(bounds: Bounds, minGap: number): Bounds;
+    protected scaleZoneAroundCenter(bounds: Bounds, newExclusiveRange: number, minGap: number): Bounds;
+    protected pushKnobsRight(values: number[], fromIndex: number, minGap: number): number[];
+    protected pushKnobsLeft(values: number[], fromIndex: number, minGap: number): number[];
+    protected enforceGapForMovedKnob(values: Record<SliderKnobId, number>, movedKnob: SliderKnobId, minGap: number): Record<SliderKnobId, number>;
+}

package/dist/components/advanced-dice/strategies/index.d.ts

@@ -0,0 +1,4 @@
+export { BaseRollTypeStrategy } from './base-roll-type.strategy';
+export { RollBetweenStrategy } from './roll-between.strategy';
+export { RollOutsideStrategy } from './roll-outside.strategy';
+export { RollBetweenTwoStrategy } from './roll-between-two.strategy';

package/dist/components/advanced-dice/strategies/roll-between-two.strategy.d.ts

@@ -0,0 +1,20 @@
+import { BaseRollTypeStrategy } from './base-roll-type.strategy';
+import { BoundsData, BoundsValidationResult, SliderPositions, SliderKnobId, RollType, Bounds } from '../advanced-dice.types';
+export declare class RollBetweenTwoStrategy extends BaseRollTypeStrategy {
+    readonly rollType = RollType.ROLL_BETWEEN_TWO;
+    readonly knobCount: 4;
+    readonly hasSecondBounds = true;
+    getMinKnobGap(_edge: number, _minMultiplier: number | null): number;
+    getMaxKnobGap(edge: number, minMultiplier: number | null): number;
+    calculateWinRange(bounds: Bounds, secondBounds?: Bounds): number;
+    isWinningResult(bounds: Bounds, secondBounds: Bounds | undefined, result: number): boolean;
+    scaleBoundsForWinChance(currentBounds: Bounds, currentSecondBounds: Bounds | undefined, newWinChance: number, edge: number, minMultiplier: number | null): BoundsData;
+    validateBounds(bounds: Bounds, secondBounds: Bounds | undefined, edge: number, minMultiplier: number | null): BoundsValidationResult;
+    protected buildProposedBounds(currentBounds: Bounds, currentSecondBounds: Bounds | undefined, knobId: SliderKnobId, newValueInternal: number): BoundsData;
+    protected getKnobAllowedRange(knobId: SliderKnobId, currentPositions: SliderPositions, edge: number, minMultiplier: number | null): {
+        min: number;
+        max: number;
+    };
+    sliderPositionsToBounds(positions: SliderPositions): BoundsData;
+    getBoundsFromKnobChange(currentBounds: Bounds, currentSecondBounds: Bounds | undefined, knobId: SliderKnobId, newValueDisplay: number, edge: number, minMultiplier: number | null): BoundsData;
+}

package/dist/components/advanced-dice/strategies/roll-between.strategy.d.ts

@@ -0,0 +1,12 @@
+import { BaseRollTypeStrategy } from './base-roll-type.strategy';
+import { BoundsData, RollType, Bounds } from '../advanced-dice.types';
+export declare class RollBetweenStrategy extends BaseRollTypeStrategy {
+    readonly rollType = RollType.ROLL_BETWEEN;
+    readonly knobCount: 2;
+    readonly hasSecondBounds = false;
+    getMinKnobGap(_edge: number, _minMultiplier: number | null): number;
+    getMaxKnobGap(edge: number, minMultiplier: number | null): number;
+    calculateWinRange(bounds: Bounds): number;
+    isWinningResult(bounds: Bounds, _secondBounds: Bounds | undefined, result: number): boolean;
+    scaleBoundsForWinChance(currentBounds: Bounds, _currentSecondBounds: Bounds | undefined, newWinChance: number, edge: number, minMultiplier: number | null): BoundsData;
+}

package/dist/components/advanced-dice/strategies/roll-outside.strategy.d.ts

@@ -0,0 +1,19 @@
+import { BaseRollTypeStrategy } from './base-roll-type.strategy';
+import { BoundsData, BoundsValidationResult, SliderPositions, SliderKnobId, RollType, Bounds } from '../advanced-dice.types';
+export declare class RollOutsideStrategy extends BaseRollTypeStrategy {
+    readonly rollType = RollType.ROLL_OUTSIDE;
+    readonly knobCount: 2;
+    readonly hasSecondBounds = false;
+    private readonly minLowerBound;
+    private readonly maxUpperBound;
+    getMinKnobGap(edge: number, minMultiplier: number | null): number;
+    getMaxKnobGap(_edge: number, _minMultiplier: number | null): number;
+    calculateWinRange(bounds: Bounds): number;
+    isWinningResult(bounds: Bounds, _secondBounds: Bounds | undefined, result: number): boolean;
+    scaleBoundsForWinChance(currentBounds: Bounds, _currentSecondBounds: Bounds | undefined, newWinChance: number, edge: number, minMultiplier: number | null): BoundsData;
+    validateBounds(bounds: Bounds, secondBounds: Bounds | undefined, edge: number, minMultiplier: number | null): BoundsValidationResult;
+    protected getKnobAllowedRange(knobId: SliderKnobId, currentPositions: SliderPositions, edge: number, minMultiplier: number | null): {
+        min: number;
+        max: number;
+    };
+}

package/dist/components/advanced-dice/strategies/roll-type-strategy.factory.d.ts

@@ -0,0 +1,3 @@
+import { RollType } from '../advanced-dice.types';
+import { BaseRollTypeStrategy } from './base-roll-type.strategy';
+export declare const ADVANCED_DICE_STRATEGIES: Record<RollType, BaseRollTypeStrategy>;

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

@@ -0,0 +1,11 @@
+import { LitElement } from 'lit';
+import { BaccaratBetType } from '@betorigami/game-calculations';
+export declare class BaccaratBetButton extends LitElement {
+    static styles: import('lit').CSSResult[];
+    type: BaccaratBetType;
+    label?: string;
+    disabled: boolean;
+    amount: number;
+    showHotkeys: boolean;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

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

@@ -0,0 +1,39 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+import { GameRound } from '../baccarat.types';
+import { BaccaratBetType } from '@betorigami/game-calculations';
+export declare class BaccaratContent extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    isDesktop: boolean;
+    isPlaying: boolean;
+    gameWinPopupShowing: boolean;
+    gameRound: GameRound | null;
+    instantMode: boolean;
+    slowReveal: boolean;
+    gameData?: gameContextType;
+    placedChips: Map<BaccaratBetType, number>;
+    canUndo: boolean;
+    canClear: boolean;
+    private cardStack;
+    private baccaratDisplay;
+    private playerCards;
+    private bankerCards;
+    private displayedWinner;
+    private _slowRevealActive;
+    private get showHotkeys();
+    private lastProcessedRoundId;
+    onGameRoundChange(): Promise<void>;
+    private dealInstant;
+    /**
+     * Deal cards with sequential animation.
+     * Cards are added one by one, animated, then flipped.
+     */
+    private dealAnimated;
+    private _revealResolve;
+    private awaitReveals;
+    private dealSlowReveal;
+    private dealCardsFaceDown;
+    private handleCardReveal;
+    private handleChipInteraction;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

package/dist/components/baccarat/BaccaratControls/BaccaratAuto.d.ts

@@ -0,0 +1,18 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class BaccaratAuto extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    inputsDisabled: boolean;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    betDisabled: boolean;
+    isDesktop: boolean;
+    perClickAmount: string;
+    totalBetAmount: string;
+    maxPerClickAmount?: string;
+    noChips: boolean;
+    gameData?: gameContextType;
+    private isBetAmountValid;
+    private handlePerClickAmountChange;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

package/dist/components/baccarat/BaccaratControls/BaccaratManual.d.ts

@@ -0,0 +1,19 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../../shared/context/game.context';
+export declare class BaccaratManual extends OrigamiElement {
+    isPlaying: boolean;
+    betDisabled: boolean;
+    inputsDisabled: boolean;
+    noChips: boolean;
+    slowReveal: boolean;
+    perClickAmount: string;
+    totalBetAmount: string;
+    maxPerClickAmount?: string;
+    gameData: gameContextType;
+    private isBetAmountValid;
+    private _betAboveBalance;
+    static styles: import('lit').CSSResult[];
+    private handlePerClickAmountChange;
+    private handleSlowRevealToggle;
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,22 @@
+import { LitElement } from 'lit';
+import { DisplayedCard } from '../baccarat.types';
+import { BaccaratOutcome } from '@betorigami/game-calculations';
+import { OrigamiCard } from '../../../shared/cards/Card';
+export declare class BaccaratDisplay extends LitElement {
+    static styles: import('lit').CSSResult[];
+    playerCards: DisplayedCard[];
+    bankerCards: DisplayedCard[];
+    displayedWinner: BaccaratOutcome | null;
+    instantMode: boolean;
+    slowReveal: boolean;
+    outcomeDisplay: boolean;
+    cardBackImageUrl: string | null;
+    private cards;
+    /** Get a card element by its ID. Used by parent for animations. */
+    getCardById(cardId: string): OrigamiCard | undefined;
+    private get displayedPlayerValue();
+    private get displayedBankerValue();
+    private handleCardClick;
+    private renderHand;
+    render(): import('lit').TemplateResult<1>;
+}

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

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