@betorigami/games 2.10.1 → 2.10.2

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

@@ -0,0 +1,106 @@
+import { ContextProvider } from '@lit/context';
+import { PropertyValues } from 'lit';
+import { Currency, OrigamiGame } from '../../shared/constants';
+import { default as OrigamiElement } from '../../shared/origami-element';
+import { Language } from '../../translations';
+import { gameContext, gameContextType } from './context/game.context';
+import { default as Big } from 'big.js';
+export declare class GameProviderWrapper extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    currency: Currency;
+    balance: number;
+    currencyDecimals: number;
+    baseUrl: string;
+    authToken: string;
+    origamiGame: OrigamiGame;
+    lobbyUrl: string;
+    depositUrl: string | undefined;
+    maxPayout: number | null;
+    minBet: number | null;
+    maxBet: number | null;
+    edge: 1 | 2 | 3 | 4 | 8;
+    showCurrencyAsText: boolean;
+    footerPosition: 'ABOVE' | 'BELOW';
+    logoUrl: string | null;
+    alwaysEnableMaxBetButton: boolean;
+    gcCurrencyIconSvgUrl: string | null;
+    scCurrencyIconSvgUrl: string | null;
+    customMinesBackgroundSvgUrl: string | null;
+    customMinesGemSvgUrl: string | null;
+    customMinesBombSvgUrl: string | null;
+    customMinesTileSvgUrl: string | null;
+    customMinesAutobetSelectedTileSvgUrl: string | null;
+    customKenoBackgroundSvgUrl: string | null;
+    customKenoGemSvgUrl: string | null;
+    customKenoNonMatchTileSvgUrl: string | null;
+    customKenoTileSvgUrl: string | null;
+    customKenoSelectedTileSvgUrl: string | null;
+    customRouletteBackgroundSvgUrl: string | null;
+    roulettePreventOppositeBets: boolean;
+    rouletteDefaultInstantBet: boolean;
+    customDiceBackgroundSvgUrl: string | null;
+    diceMinMultiplier: number | null;
+    advancedDiceMinMultiplier: number | null;
+    customAdvancedDiceBackgroundSvgUrl: string | null;
+    customPlinkoBackgroundSvgUrl: string | null;
+    customPlinkoEdgeColor: string | null;
+    customPlinkoCenterColor: string | null;
+    customBaccaratBackgroundSvgUrl: string | null;
+    baccaratPreventOppositeBets: boolean;
+    customLimboBackgroundSvgUrl: string | null;
+    customWheelBackgroundSvgUrl: string | null;
+    customWheelCenterSvgUrl: string | null;
+    customWheelCenterPadding: number | null;
+    customDiamondsBackgroundSvgUrl: string | null;
+    customBlackjackBackgroundSvgUrl: string | null;
+    customBlitzBackgroundSvgUrl: string | null;
+    blitzMinPickCount: number | null;
+    blitzMaxPickCount: number | null;
+    customCardBackSvgUrl: string | null;
+    customCardRedColor: string | null;
+    customCardBlackColor: string | null;
+    customFooterLobbySvgUrl: string | null;
+    customFooterVolumeSvgUrl: string | null;
+    customFooterGameInfoSvgUrl: string | null;
+    customFooterInstantBetSvgUrl: string | null;
+    customFooterHotkeysSvgUrl: string | null;
+    customFooterProvablyFairSvgUrl: string | null;
+    private betAmount;
+    private autobetNumberOfBets;
+    private hotkeysOpenEnabled;
+    private showMaxBetButton;
+    private volume;
+    private instantBetEnabled;
+    private mainWidth;
+    private publicKey;
+    private scale;
+    language: Language;
+    private _soundEffects;
+    private _historyController;
+    private _haptics;
+    private _resizeObserver;
+    private hasLoadedBalance;
+    protected _gameProvider: ContextProvider<typeof gameContext>;
+    connectedCallback(): void;
+    firstUpdated(_changed: PropertyValues): Promise<void>;
+    disconnectedCallback(): void;
+    updated(changedProperties: PropertyValues): void;
+    get gameData(): gameContextType;
+    private createGameContextValue;
+    private updateProviderValue;
+    private fetchBalance;
+    private fetchPublicKey;
+    updateHotkeysOpenEnabled(enabled: boolean): void;
+    updateShowMaxBetButton(enabled: boolean): void;
+    updateVolume(volume: number): void;
+    updateInstantBetEnabled(enabled: boolean): void;
+    updateAutobetNumberOfBets(numberOfBets: number): void;
+    updateMainWidth(width: number): void;
+    updateBetAmount(newAmount: Big): void;
+    updateBalance(newAmount: Big): void;
+    private _boundCalculateScale;
+    private setupResizeObserver;
+    private cleanupResizeObserver;
+    private calculateScale;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

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

@@ -0,0 +1,16 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../context/game.context';
+export type BetMode = 'Manual' | 'Auto';
+export declare class GameSidebar extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    gameData?: gameContextType;
+    mode: BetMode;
+    betAmount: string;
+    toggleDisabled: boolean;
+    option1Label: string;
+    option2Label: string;
+    isLoading: boolean;
+    className: string;
+    private _handleToggleChange;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

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

@@ -0,0 +1,27 @@
+import { TemplateResult } from 'lit';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { default as Big } from 'big.js';
+type GameType = 'Keno' | 'Mines' | 'Roulette';
+export declare class GameWinPopup extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    payout: Big | null;
+    multiplier: number | undefined;
+    currencySymbol: string;
+    title: string;
+    description: string;
+    gemCount: number | undefined;
+    gameType: GameType;
+    betId?: string;
+    isLoss: boolean;
+    isPush: boolean;
+    private betResultCache;
+    private gameConsumer;
+    private get disableBetResultModal();
+    constructor();
+    disconnectedCallback(): void;
+    private handleClick;
+    private handleMouseEnter;
+    updated(changedProperties: Map<string, any>): void;
+    render(): TemplateResult<1>;
+}
+export {};

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

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

package/dist/components/shared/GenericAutobet/BetCountInput.d.ts

@@ -0,0 +1,12 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../context/game.context';
+export declare class BetCountInput extends OrigamiElement {
+    gameData?: gameContextType;
+    disabled: boolean;
+    static styles: import('lit').CSSResult[];
+    private _handleAutobetGamesChange;
+    private _handleAutobetGamesBlur;
+    private preventNonWholeNumberInput;
+    private _handleResetToZero;
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,52 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { ContextProvider } from '@lit/context';
+import { gameContextType } from '../context/game.context';
+export type AfterBetEffect = 'Reset' | 'Increase';
+export type AutobetValues = {
+    onWinPercentage: string;
+    onLossPercentage: string;
+    stopOnProfit: string;
+    stopOnLoss: string;
+    onLossStrategy: AfterBetEffect;
+    onWinStrategy: AfterBetEffect;
+};
+export declare const defaultAutobetValues: AutobetValues;
+export type AutobetEventPayload = AutobetValues & {
+    numberOfBets: string;
+};
+export declare class GenericAutobet extends OrigamiElement {
+    inputsDisabled: boolean;
+    autobetSettings: AutobetValues;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    betDisabled: boolean;
+    private _isStarting;
+    private _onWinFocused;
+    private _onLossFocused;
+    private _stopOnLossFocused;
+    private _stopOnProfitFocused;
+    private isBetAmountValid;
+    private _showConfig;
+    private _betAboveBalance;
+    betMaxMultiplier: number;
+    hasCustomBetAmountSection: boolean;
+    disableBetAmountHotkeys: boolean;
+    gameData: gameContextType;
+    customInputsSlot?: HTMLSlotElement;
+    private betButtonEl?;
+    static styles: import('lit').CSSResult[];
+    protected _autobetProvider: ContextProvider<{
+        __context__: import('./context/autobet.context').AutobetContextType;
+    }, this>;
+    willUpdate(changedProperties: Map<string | symbol, unknown>): void;
+    updateNumberOfBets(numberOfBets: string): void;
+    triggerPrimaryAction(): void;
+    isPrimaryActionDisabled(): boolean;
+    private _handleWinPercentageChange;
+    private _handleLossPercentageChange;
+    private _handleStopOnProfitChange;
+    private _handleStopOnLossChange;
+    private _hasCustomInputs;
+    private betButtonClick;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

package/dist/components/shared/GenericAutobet/context/autobet.context.d.ts

@@ -0,0 +1,13 @@
+import { Language } from '../../../../translations';
+import { SelectOption } from '../../Select/Select';
+export interface AutobetContextType {
+    numberOfBets: string;
+    updateNumberOfBets: (numberOfBets: string) => void;
+}
+export declare const getAutobetGamesOptions: (language?: Language) => SelectOption[];
+export declare const autobetGamesOptions: SelectOption[];
+export declare const defaultNumberOfBetsValue: string;
+export declare const autobetContext: {
+    __context__: AutobetContextType;
+};
+export declare const defaultAutobetContext: AutobetContextType;

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

@@ -0,0 +1,27 @@
+import { PropertyValues } from 'lit';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export interface HistoryItem {
+    multiplier: number;
+    won: boolean;
+    id: string;
+    color?: string;
+}
+export declare class HistoryPills extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    history: HistoryItem[];
+    showMultiplierSuffix: boolean;
+    fadeOpacity: boolean;
+    private animatingInIds;
+    private betResultCache;
+    private gameConsumer;
+    get disableHistoryModal(): boolean;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    handleHistoryChange(oldHistory: HistoryItem[]): void;
+    private handleAnimationEnd;
+    private formatMultiplier;
+    private handleHistoryPillClick;
+    private handlePillKeyDown;
+    private handleHistoryPillHover;
+    private renderHistoryPill;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

package/dist/components/shared/HotkeysModal/HotKeysModal.styles.d.ts

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

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

@@ -0,0 +1,10 @@
+import { OrigamiGame } from '../../../shared/constants';
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class HotkeysModal extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    private gameConsumer;
+    gameType: OrigamiGame;
+    private getRows;
+    private renderRow;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Inputs/BetAmountInput/BetAmountInput.d.ts

@@ -0,0 +1,44 @@
+import { PropertyValues } from 'lit';
+import { default as OrigamiElement } from '../../../../shared/origami-element';
+export declare enum InvalidReason {
+    BET_AMOUNT_BELOW_MIN_BET = "BET_AMOUNT_BELOW_MIN_BET",
+    BET_AMOUNT_ABOVE_MAX_BET = "BET_AMOUNT_ABOVE_MAX_BET",
+    BET_AMOUNT_ABOVE_BALANCE = "BET_AMOUNT_ABOVE_BALANCE"
+}
+export declare class BetAmountInput extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    get gameData(): import('../../context/game.context').gameContextType;
+    private isFocused;
+    private invalidReason;
+    betMaxMultiplier: number | null;
+    isGameActive: boolean;
+    halfBetDisabled: boolean;
+    doubleBetDisabled: boolean;
+    maxAmount?: string;
+    private _gameContext;
+    firstUpdated(): void;
+    watchValue(): void;
+    updated(changedProperties: PropertyValues): void;
+    validateBetAmount(): void;
+    private value;
+    private _isInitialized;
+    disabled: boolean;
+    readonly: boolean;
+    allowZero: boolean;
+    externalControl: boolean;
+    disableHotkeys: boolean;
+    externalValue?: string;
+    initialValue?: string;
+    label: string;
+    halfButtonHotkey?: string;
+    doubleButtonHotkey?: string;
+    constructor();
+    updateBetAmountState(newAmount: string): void;
+    private handleCurrencyInputChange;
+    private updateAmount;
+    private handleHalfBet;
+    private handleDoubleBet;
+    private handleZeroBet;
+    private handleMaxBet;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Inputs/ChipInput/ChipInput.d.ts

@@ -0,0 +1,19 @@
+import { default as OrigamiElement } from '../../../../shared/origami-element';
+import { gameContextType } from '../../context/game.context';
+import { ChipConfig } from '../../types/chip.types';
+export declare class ChipInput extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    chips: ChipConfig[];
+    disabled: boolean;
+    private selectedIndex;
+    gameData?: gameContextType;
+    /**
+     * Parse a chip label like "0.1", "10", "1K", "10K", "1M" into its numeric value.
+     * This is used only for display of the chip value hint in the UI.
+     */
+    private parseChipLabelToUnits;
+    private handlePointerDown;
+    private handleSelect;
+    private renderChip;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Inputs/ChipInput/ChipInput.styles.d.ts

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

package/dist/components/shared/Inputs/ChipInput/chip-input.constants.d.ts

@@ -0,0 +1,4 @@
+import { ChipConfig, themeToColors } from '../../types/chip.types';
+export type { ChipConfig, ChipTheme } from '../../types/chip.types';
+export { themeToColors };
+export declare const DEFAULT_CHIPS: ChipConfig[];

package/dist/components/shared/Inputs/CurrencyInput/RawCurrencyInput.d.ts

@@ -0,0 +1,36 @@
+import { PropertyValues } from 'lit';
+import { default as OrigamiElement } from '../../../../shared/origami-element';
+import { Input } from '../Input/Input';
+import { Currency } from '../../../../shared/constants';
+import { gameContextType } from '../../context/game.context';
+export declare class RawCurrencyInput extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    gameData: gameContextType;
+    label: string;
+    currency: Currency;
+    errorMessage: string;
+    value: string;
+    rightLabel: string;
+    suffix: string;
+    placeholder: string;
+    disabled: boolean;
+    readonly: boolean;
+    disableInput: boolean;
+    cursorNotAllowed: boolean;
+    bgColor: string;
+    testId: string;
+    tooltip: string;
+    maxBetEnabled: boolean;
+    dimmed: boolean;
+    maxPayoutUSD: number;
+    variant: 'primary' | 'secondary';
+    required: boolean;
+    hideCurrencyIcon: boolean;
+    input: Input;
+    private formatValue;
+    private handleChange;
+    private handleBlur;
+    private handleFocus;
+    updated(changedProperties: PropertyValues): void;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Inputs/CurrencyInput/RawCurrencyInput.styles.d.ts

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

package/dist/components/shared/Inputs/Input/Input.d.ts

@@ -0,0 +1,74 @@
+import { default as OrigamiElement } from '../../../../shared/origami-element';
+import { gameContextType } from '../../context/game.context';
+export interface InputAddonButton {
+    label: string;
+    'aria-label'?: string;
+    selected?: boolean;
+    disabled?: boolean;
+    onClick?: () => void;
+}
+export type InputType = 'text' | 'number' | 'password' | 'email' | 'search' | 'tel' | 'url' | 'date' | 'time' | 'datetime-local';
+export type InputMode = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+export declare const ValidationPatterns: {
+    email: RegExp;
+    url: RegExp;
+    phone: RegExp;
+    number: RegExp;
+    integer: RegExp;
+    alphabetic: RegExp;
+    alphanumeric: RegExp;
+};
+export declare class Input extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    gameData?: gameContextType;
+    value: string;
+    label: string;
+    placeholder: string;
+    type: InputType;
+    disabled: boolean;
+    rightText: string | null;
+    min: number | null;
+    max: number | null;
+    step: number | 'any' | null;
+    addonButtonsPosition: 'left' | 'right';
+    name: string | null;
+    autocomplete: string | null;
+    required: boolean;
+    readonly: boolean;
+    pattern: string | null;
+    validateOnInput: boolean;
+    tooltipFullWidth: boolean;
+    validationPattern: string | null;
+    validationMessage: string | null;
+    hideRightLabel: boolean;
+    clickable: boolean;
+    forceActiveBorder: boolean;
+    keepLabelEnabled: boolean;
+    handleBeforeInput: ((e: InputEvent & {
+        dataTransfer?: DataTransfer | null;
+    }) => void) | null;
+    wrapperClasses: Record<string, boolean>;
+    tooltipOffset: number;
+    errorMessage: string | null;
+    private _isIconRotating;
+    private _hasRightIcon;
+    private _hasLeftIcon;
+    private _hasLeftAddon;
+    private _hasRightAddon;
+    private _hasRightLabel;
+    private _iconRotationState;
+    private _isFocused;
+    private inputRef;
+    private inputId;
+    private errorId;
+    private hasActualContent;
+    private handleSlotChange;
+    firstUpdated(): void;
+    private handleInput;
+    private handlePaste;
+    private handleClick;
+    private handleAnimationEnd;
+    private handleFocus;
+    private handleBlur;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/shared/Inputs/Input/Input.styles.d.ts

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

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

@@ -0,0 +1,24 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class LottieIcon extends OrigamiElement {
+    static styles: import('lit').CSSResult;
+    src: string;
+    size: string;
+    triggerSelector: string;
+    active: boolean;
+    autoplay: boolean;
+    tone: 'default' | 'success' | 'error';
+    private animation;
+    private containerRef;
+    private abortController;
+    private lottieModule;
+    connectedCallback(): Promise<void>;
+    disconnectedCallback(): void;
+    private initialize;
+    private loadLottieModule;
+    private loadAnimationData;
+    private setupAnimation;
+    private setupTriggers;
+    private playAnimation;
+    private cleanup;
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,29 @@
+import { default as OrigamiElement } from '../../../shared/origami-element.js';
+import { default as FocusTrap } from '../../../utils/focus-trap.js';
+import { gameContextType } from '../context/game.context';
+export default class OrigamiModal extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    private originalTrigger;
+    gameData?: gameContextType;
+    focusTrap: FocusTrap;
+    private closeWatcher;
+    fixedPosition: boolean;
+    dialog: HTMLElement;
+    panel: HTMLElement;
+    overlay: HTMLElement;
+    open: boolean;
+    label: string;
+    lockScrolling: boolean;
+    noHeader: boolean;
+    noFooter: boolean;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+    private requestClose;
+    private addOpenListeners;
+    private removeOpenListeners;
+    private handleDocumentKeyDown;
+    handleOpenChange(): Promise<void>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

package/dist/components/shared/Modal/Portal.d.ts

@@ -0,0 +1,13 @@
+import { LitElement } from 'lit';
+export declare class Portal extends LitElement {
+    to?: string;
+    containerClass: string;
+    body: import('lit').TemplateResult<1>;
+    uniqueID: string;
+    private getOrCreateDestination;
+    private getOrCreateContainer;
+    private removeContainer;
+    updated(changedProperties: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    render(): void;
+}

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

@@ -0,0 +1,17 @@
+import { default as OrigamiElement } from '../../../shared/origami-element.js';
+export declare class ResponsiveModal extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    showFooter: boolean;
+    open: boolean;
+    label: string;
+    width: string;
+    private internalOpen;
+    private openDebounceTimeout?;
+    private isAnimating;
+    openChanged(): void;
+    disconnectedCallback(): void;
+    handleCloseEvent(): void;
+    handleShowEvent(): void;
+    handleHideEvent(): void;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

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

@@ -0,0 +1,34 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export interface SelectOption<T extends string = string> {
+    value: T;
+    label: string;
+    disabled?: boolean;
+    group?: string;
+}
+export declare class Select extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    private gameData?;
+    dir: string;
+    label: string;
+    options: SelectOption[];
+    placeholder: string;
+    helperText: string | null;
+    disabled: boolean;
+    required: boolean;
+    defaultValue: string | null;
+    id: string;
+    name: string;
+    error: string;
+    size: number | null;
+    autoFocus: boolean;
+    private _errorMessage;
+    value: string;
+    private _generatedId;
+    get _effectiveId(): string;
+    private getGroupedOptions;
+    private handleChange;
+    private validate;
+    private generateOptionElements;
+    private renderOption;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

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

@@ -0,0 +1,5 @@
+import { LitElement } from 'lit';
+export declare class Spinner extends LitElement {
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<2>;
+}

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

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

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

@@ -0,0 +1,11 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class Switch extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    private gameContext?;
+    checked: boolean;
+    disabled: boolean;
+    label: string;
+    private handlePointerDown;
+    private handleClick;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

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

@@ -0,0 +1,15 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class Toggle extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    private gameContext?;
+    option1: string;
+    option2: string;
+    option1Value: string;
+    option2Value: string;
+    value: string;
+    disabled: boolean;
+    name: string;
+    private handlePointerDown;
+    private handleOptionClick;
+    render(): import('lit').TemplateResult<1>;
+}