@betorigami/games 0.0.1

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

@@ -0,0 +1,11 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { MinesState } from '../mines.constants';
+export declare class MinesManual extends OrigamiElement {
+    inputsDisabled: boolean;
+    minesCount: number;
+    minesState: MinesState | null;
+    isGameActive: boolean;
+    selectedTilesCount: number;
+    static styles: import('lit').CSSResult[];
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/mines/MinesGame.d.ts

@@ -0,0 +1,34 @@
+import { MinesApi } from './mines.api';
+import { MinesState } from './mines.constants';
+import { AutobetToggleEvent } from '../../shared/event-map';
+import { AutobetSettings, GameBetResult, GameComponent } from '../shared/GameComponent';
+import { MockMinesApi } from './mines.mock.api';
+export declare class MinesGame extends GameComponent {
+    private minesCount;
+    private autobetSelectedTiles;
+    private minesData;
+    authToken: string;
+    get isGameActive(): boolean;
+    get minesApi(): MinesApi | MockMinesApi;
+    getMinesActiveBet(): Promise<void>;
+    protected firstUpdated(): Promise<void>;
+    get getMinesState(): MinesState | null;
+    protected executeBet(_autobetSettings: AutobetSettings, currentBetAmount: string): Promise<GameBetResult>;
+    toggleAutobet(event: AutobetToggleEvent): Promise<void>;
+    private minesClickHandler;
+    minesManualStart(): Promise<void>;
+    minesChooseRandomTile(): Promise<void>;
+    minesNext(selectedTile: number): Promise<void>;
+    minesCashout(): Promise<void>;
+    onManualOrAutoChange(): void;
+    onMinesCountChange(): void;
+    render(): import('lit').TemplateResult<1>;
+}
+/**
+ * Things to do
+ * reset mines content between bets in autobet
+ * scaling animation when the tiles disappear
+ * animation for game win popup
+ * scale icons for gems and bombs
+ * autobet btn hover effect isn't aligned (need styles for active, hover states for each button)
+ */

package/dist/components/mines/MinesGrid/MinesGrid.d.ts

@@ -0,0 +1,29 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { MinesFlowState } from '../mines.constants';
+export interface Tile {
+    id: number;
+    isMine: boolean;
+    isRevealed: boolean;
+    wasAutoRevealed: boolean;
+}
+export declare class MinesGrid extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    isAuto: boolean;
+    autobetSelectedTiles: number[];
+    autobetInProgress: boolean;
+    minesState: {
+        selectedTiles: number[];
+        state: MinesFlowState;
+        mineLocations: number[];
+    } | null;
+    hasWon: boolean;
+    hitBomb: boolean;
+    get tiles(): {
+        id: number;
+        isMine: boolean;
+        isRevealed: boolean;
+        wasAutoRevealed: boolean | undefined;
+    }[];
+    private calculateTileState;
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/mines/MinesGrid/MinesGrid.styles.d.ts

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

package/dist/components/mines/MinesTile/MinesTile.d.ts

@@ -0,0 +1,21 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare enum MinesTileState {
+    NORMAL = "NORMAL",
+    AUTOBET_SELECTED = "AUTOBET_SELECTED",
+    SELECTED_GEM = "SELECTED_GEM",
+    UNSELECTED_GEM = "UNSELECTED_GEM",
+    SELECTED_BOMB = "SELECTED_BOMB",
+    UNSELECTED_BOMB = "UNSELECTED_BOMB",
+    AUTOBET_SELECTED_GEM = "AUTOBET_SELECTED_GEM",
+    AUTOBET_SELECTED_BOMB = "AUTOBET_SELECTED_BOMB"
+}
+export declare class MinesTile extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    tileId: number;
+    delayReveal: boolean;
+    state: MinesTileState;
+    ariaLabel: string;
+    private _handleClick;
+    private get _isDisabled();
+    render(): import('lit').TemplateResult<1>;
+}

package/dist/components/mines/MinesTile/MinesTile.styles.d.ts

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

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

@@ -0,0 +1,122 @@
+import { default as BigNumber } from 'bignumber.js';
+import { Currency } from '../../shared/constants';
+import { OrigamiActionType } from '../../shared/origami-action.type';
+import { MinesGameOutcome, MinesState } from './mines.constants';
+export interface MinesData {
+    minesResult: number[];
+    minesCount: number;
+    winMultiplier: string;
+    selected: number[];
+}
+export interface MinesAction {
+    id: string;
+    data: {
+        mines: MinesData;
+    };
+    type: OrigamiActionType;
+    actionIndex: number;
+    originalActionId: string | null;
+    betAmount: string;
+    payoutAmount: string;
+}
+export interface BetResult {
+    id: string;
+    tenantId: string;
+    userId: string;
+    usdRate: number;
+    gameId: string;
+    currency: Currency;
+    edge: number;
+    amount: string;
+    payout: string;
+    afterBalance: string;
+    maxPayoutReached: boolean;
+    multiplier: number;
+    clientSeed: string;
+    randomValue: string;
+    proof: string | null;
+    nonce: string | null;
+    completedAt: string | null;
+    actions: MinesAction[];
+}
+export type MinesManualStartArgs = {
+    currency: Currency;
+    amount: string;
+    windowId?: string;
+    usdAmount?: number;
+    minesCount: number;
+};
+export type MinesNextArgs = {
+    betId: string;
+    selected: number[];
+};
+export type MinesAutoArgs = {
+    currency: Currency;
+    amount: string;
+    windowId?: string;
+    usdAmount?: number;
+    minesCount?: number;
+    selected: number[];
+};
+export declare class MinesApi {
+    private authToken;
+    private baseUrl;
+    constructor(authToken: string, baseUrl: string);
+    static DEFAULT_MINES_QTY: number;
+    static MINES_TILES_COUNT: number;
+    startManualBet(data: MinesManualStartArgs): Promise<{
+        success: true;
+        data: BetResult;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        data?: undefined;
+    }>;
+    getActiveBet(): Promise<{
+        success: true;
+        data: BetResult;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        data?: undefined;
+    }>;
+    selectTile(minesNextArgs: MinesNextArgs): Promise<{
+        success: true;
+        data: BetResult;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        data?: undefined;
+    }>;
+    cashout(): Promise<{
+        success: true;
+        data: BetResult;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        data?: undefined;
+    }>;
+    autobetPlay(data: MinesAutoArgs): Promise<{
+        success: true;
+        data: BetResult;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        data?: undefined;
+    }>;
+    static deriveSelectedTiles: (actions?: Array<MinesAction> | null) => number[];
+    static deriveMineLocations: (actions?: Array<MinesAction> | null) => number[];
+    static getMinesBetInfo: (actions: MinesAction[]) => {
+        selected: number[];
+        mines: number[];
+    };
+    static deriveOutcome: (bet?: BetResult) => MinesGameOutcome | null;
+    static deriveAutoOutcome: (bet?: BetResult | null) => MinesGameOutcome | null;
+    static calculateMinesMultiplier: (gemsFound: number, mines: number) => BigNumber;
+    static getState: (bet: BetResult) => MinesState;
+}

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

@@ -0,0 +1,22 @@
+import { default as BigNumber } from 'bignumber.js';
+import { Currency } from '../../shared/constants';
+export declare enum MinesGameOutcome {
+    WIN = "WIN",
+    LOSS = "LOSS"
+}
+export declare enum MinesFlowState {
+    NO_GAME_ACTIVE = "NO_GAME_ACTIVE",
+    GAME_IN_PROGRESS = "GAME_IN_PROGRESS",
+    VIEWING_RESULTS = "VIEWING_RESULTS"
+}
+export interface MinesState {
+    currency?: Currency;
+    selectedTiles: number[];
+    mineLocations: number[];
+    outcome: MinesGameOutcome | null;
+    minesCount: number;
+    numMinesRemaining: number;
+    numGemsRemaining: number;
+    state: MinesFlowState;
+    betAmount: BigNumber;
+}

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

@@ -0,0 +1,50 @@
+import { BetResult, MinesApi, MinesAutoArgs, MinesManualStartArgs, MinesNextArgs } from './mines.api';
+export interface MockMinesSettings {
+    shouldWin: boolean;
+    minePositions?: number[];
+}
+export declare class MockMinesApi extends MinesApi {
+    private static mockSettings;
+    private static activeBet;
+    private static minePositions;
+    static setMockSettings(settings: MockMinesSettings): void;
+    private static getRandomValueInRange;
+    private static generateMinePositions;
+    private static addAction;
+    private static updateBetResult;
+    startManualBet(data: MinesManualStartArgs): Promise<{
+        success: true;
+        data: BetResult;
+    }>;
+    getActiveBet(): Promise<{
+        success: false;
+        error: string;
+        data?: undefined;
+    } | {
+        success: true;
+        data: BetResult;
+        error?: undefined;
+    }>;
+    selectTile(data: MinesNextArgs): Promise<{
+        success: false;
+        error: string;
+        data?: undefined;
+    } | {
+        success: true;
+        data: BetResult;
+        error?: undefined;
+    }>;
+    cashout(): Promise<{
+        success: false;
+        error: string;
+        data?: undefined;
+    } | {
+        success: true;
+        data: BetResult;
+        error?: undefined;
+    }>;
+    autobetPlay(data: MinesAutoArgs): Promise<{
+        success: true;
+        data: BetResult;
+    }>;
+}

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

@@ -0,0 +1,45 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { DiceData } from '../../dice/dice.api';
+import { KenoData } from '../../keno/keno.api';
+import { LimboData } from '../../limbo/limbo.api';
+import { MinesData } from '../../mines/mines.api';
+export type GameType = "mines" | "dice" | "keno" | "limbo";
+export interface GameAction {
+    id: string;
+    data: {
+        dice?: DiceData;
+        mines?: MinesData;
+        keno?: KenoData;
+        limbo?: LimboData;
+    };
+    type: string;
+    actionIndex: number;
+    originalActionId: string | null;
+    betAmount: string;
+    payoutAmount: string;
+}
+export interface BetResult {
+    id: string;
+    amount: string;
+    payout: string;
+    multiplier: number;
+    currency?: string;
+    completedAt: string | null;
+    actions: GameAction[];
+}
+export declare class BetResultModal extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    gameType: GameType;
+    betResult: BetResult | null;
+    currencySymbol: string;
+    visible: boolean;
+    variant: string;
+    private _getDummyBet;
+    private _formatAmount;
+    private _getDiceData;
+    private _getMinesData;
+    private _getKenoData;
+    private _getLimboData;
+    private _renderGameContent;
+    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,25 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export type ButtonVariant = "primary" | "secondary" | "danger" | "ghost" | "icon";
+export declare class Button extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    variant: ButtonVariant;
+    disabled: boolean;
+    ariaLabel: string | null;
+    ariaDescribedby: string | null;
+    type: string;
+    isLoading: boolean;
+    fullWidth: boolean;
+    enableHaptics: boolean;
+    /**
+     * Trigger haptic feedback
+     */
+    private triggerHapticFeedback;
+    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,6 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export declare class ButtonGroup extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    position: "left" | "right";
+    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/FairnessDetails/FairnessDetails.d.ts

@@ -0,0 +1,14 @@
+import { LitElement } from 'lit';
+export declare class FairnessDetails extends LitElement {
+    static styles: import('lit').CSSResult[];
+    private _activeTab;
+    private _publicKey;
+    private _request;
+    private _proof;
+    private _randomness;
+    private _clientSeed;
+    private _historyData;
+    private _handleToggleChange;
+    private _handleGenerateClientSeed;
+    render(): import('lit').TemplateResult<1>;
+}

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

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

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

@@ -0,0 +1,49 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { gameContextType } from '../context/game.context';
+/**
+ * Footer component with navigation and branding elements.
+ *
+ * @example
+ * // Default footer with all features enabled
+ * <origami-footer @footer-settings-click=${() => console.log('settings')}></origami-footer>
+ *
+ * // Customized footer with specific options
+ * <origami-footer
+ *   ?showLogo=${true}
+ *   .logoUrl=${'/custom-logo.svg'}
+ *   ?showTheatre=${false}
+ *   @footer-favorites-click=${() => console.log('favorites clicked')}
+ * ></origami-footer>
+ *
+ * @property {string} logoAlt - Alt text for the logo
+ * @property {boolean} showTheatre - Whether to show the theatre button
+ * @property {boolean} showStats - Whether to show the stats button
+ * @property {boolean} showFavorites - Whether to show the favorites button
+ * @property {boolean} showFairness - Whether to show the fairness button
+ *
+ * @fires {CustomEvent} footer-settings-click - Fired when the settings button is clicked
+ * @fires {CustomEvent} footer-theatre-click - Fired when the theatre button is clicked
+ * @fires {CustomEvent} footer-stats-click - Fired when the stats button is clicked
+ * @fires {CustomEvent} footer-favorites-click - Fired when the favorites button is clicked
+ * @fires {CustomEvent} footer-provably-fair-click - Fired when the fairness button is clicked
+ *
+ * @cssvar --origami-footer-background-color - Background color of the footer
+ * @cssvar --origami-footer-border-radius - Border radius of the footer
+ */
+export declare class Footer extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    gameData?: gameContextType;
+    /** Whether to show the logo. */
+    showLogo: boolean;
+    /** URL to the logo image. */
+    logoUrl: string;
+    /** Alt text for the logo. */
+    logoAlt: string;
+    showStats: boolean;
+    private handleSettingsClick;
+    private handleTheatreClick;
+    private handleStatsClick;
+    private handleFavoritesClick;
+    private handleProvablyFairClick;
+    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,35 @@
+import { default as BigNumber } from 'bignumber.js';
+import { AutobetToggleEvent } from '../../shared/event-map';
+import { default as OrigamiElement } from '../../shared/origami-element';
+import { BetMode } from './GameSidebar/GameSidebar';
+import { gameContextType } from './context/game.context';
+export interface AutobetSettings {
+    onWinStrategy: string;
+    onLossStrategy: string;
+    onWinPercentage: string | number;
+    onLossPercentage: string | number;
+    stopOnLoss: string;
+    stopOnProfit: string;
+    numberOfBets?: number;
+    autobetBets?: number;
+}
+export interface GameBetResult {
+    pnl: BigNumber;
+    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;
+    protected numberOfBets: number;
+    protected betDelay: number;
+    static styles: import('lit').CSSResult[];
+    gameData?: gameContextType;
+    toggleAutobet(event: AutobetToggleEvent): Promise<void>;
+    protected abstract executeBet(_autobetSettings: AutobetSettings, _currentBetAmount: string): Promise<GameBetResult>;
+    protected adjustBetAmount(autobetSettings: AutobetSettings, gameOutcome: "Win" | "Loss" | "Draw", originalBetAmount: string, currentBetAmount: string): string;
+    protected isPnLWithinLimits(autobetSettings: AutobetSettings, totalPnL: BigNumber): boolean;
+}

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

@@ -0,0 +1,40 @@
+import { default as OrigamiElement } from '../../../shared/origami-element.js';
+import { GameType } from '../BetResultModal/BetResultModal.js';
+import { gameContextType } from '../context/game.context';
+export declare class GameLayout extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    gameData?: gameContextType;
+    /** Additional CSS class name for the container */
+    className: string;
+    /** ID for the main game container */
+    containerId: string;
+    /** Whether to show the footer */
+    showFooter: boolean;
+    /** Whether to show the logo in the footer */
+    showLogo: boolean;
+    /** URL for the logo image */
+    logoUrl: string;
+    /** Alt text for the logo image */
+    logoAlt: string;
+    /** Whether to show the settings button */
+    showSettings: boolean;
+    /** Whether to show the theatre button */
+    showTheatre: boolean;
+    /** Whether to show the stats button */
+    showStats: boolean;
+    /** Whether to show the favorites button */
+    showFavorites: boolean;
+    /** Whether to show the Provably Fair button/link in the footer */
+    showFairness: boolean;
+    showFairnessModal: boolean;
+    betResultModalGameType: GameType | null;
+    private _handleFairnessClick;
+    private _handleGameResultModalClose;
+    private _handleFairnessModalClose;
+    private _handleSettingsClick;
+    private _handleTheatreClick;
+    private _handleStatsClick;
+    private _handleFavoritesClick;
+    private _handleOpenBetResultModal;
+    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/GameProviderWrapper.d.ts

@@ -0,0 +1,20 @@
+import { ContextProvider } from '@lit/context';
+import { PropertyValues } from 'lit';
+import { Currency } from '../../shared/constants';
+import { default as OrigamiElement } from '../../shared/origami-element';
+export declare class GameProviderWrapper extends OrigamiElement {
+    currency: Currency;
+    isTheatreMode: boolean;
+    showFavorites: boolean;
+    balance: number;
+    baseUrl: string;
+    private betAmount;
+    protected _gameProvider: ContextProvider<{
+        __context__: import('./context/game.context').gameContextType;
+    }, this>;
+    connectedCallback(): void;
+    updated(changedProperties: PropertyValues): void;
+    private updateProviderValue;
+    updateBalance(newAmount: BigNumber): void;
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,15 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+export type BetMode = "Manual" | "Autobet";
+export declare class GameSidebar extends OrigamiElement {
+    static styles: import('lit').CSSResult[];
+    mode: BetMode;
+    betAmount: string;
+    currency: string;
+    isPlaying: boolean;
+    disabled: boolean;
+    isLoading: boolean;
+    enableHaptics: 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,18 @@
+import { LitElement, TemplateResult } from 'lit';
+type GameType = "Keno" | "Mines";
+export declare class GameWinPopup extends LitElement {
+    static styles: import('lit').CSSResult[];
+    winAmount: string;
+    multiplier: number | undefined;
+    currencySymbol: string;
+    title: string;
+    description: string;
+    gemCount: number | undefined;
+    gameType: GameType;
+    /**
+     * Format win amount to 2 decimal places
+     */
+    private _getFormattedWinAmount;
+    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,11 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { AutobetContextType } from './context/autobet.context';
+export declare class BetCountInput extends OrigamiElement {
+    _autobetContext?: AutobetContextType;
+    disabled: boolean;
+    static styles: import('lit').CSSResult[];
+    private _handleAutobetGamesChange;
+    private _handleAutobetGamesBlur;
+    private preventNonWholeNumberInput;
+    render(): import('lit').TemplateResult<1>;
+}

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

@@ -0,0 +1,42 @@
+import { default as OrigamiElement } from '../../../shared/origami-element';
+import { ContextProvider } from '@lit/context';
+import { Currency } from '../../../shared/constants';
+export type AfterBetEffect = 'reset' | 'increase';
+export declare const defaultAutobetValues: {
+    onWinPercentage: string;
+    onLossPercentage: string;
+    stopOnProfit: string;
+    stopOnLoss: string;
+    onLossStrategy: AfterBetEffect;
+    onWinStrategy: AfterBetEffect;
+};
+export type AutobetValues = typeof defaultAutobetValues;
+export declare class GenericAutobet extends OrigamiElement {
+    inputsDisabled: boolean;
+    autobetSettings: {
+        onWinPercentage: string;
+        onLossPercentage: string;
+        stopOnProfit: string;
+        stopOnLoss: string;
+        onLossStrategy: AfterBetEffect;
+        onWinStrategy: AfterBetEffect;
+    };
+    currency: Currency;
+    autobetStopping: boolean;
+    readonly autobetInProgress = false;
+    profitOnWin: string;
+    betDisabled: boolean;
+    customInputsSlot?: HTMLSlotElement;
+    static styles: import('lit').CSSResult[];
+    protected _autobetProvider: ContextProvider<{
+        __context__: import('./context/autobet.context').AutobetContextType;
+    }, this>;
+    updateNumberOfBets(numberOfBets: string): void;
+    private _updateAutobetSettings;
+    private _handleWinPercentageChange;
+    private _handleLossPercentageChange;
+    private _handleStopOnProfitChange;
+    private _handleStopOnLossChange;
+    private _hasCustomInputs;
+    render(): import('lit').TemplateResult<1>;
+}

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

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