@truelab/truelogic 4.2.0 → 4.3.0-0

package/dist/types/src/shared/ui/TabBar/TabBar.stories.d.ts

@@ -0,0 +1,1804 @@
+import type { Decorator, StoryObj } from '@storybook/react-webpack5';
+declare const meta: {
+    title: string;
+    component: import("react").FC<{
+        children: import("react").ReactNode;
+        activeIndex?: number;
+    } & import("react").HTMLAttributes<HTMLDivElement>>;
+    decorators: Decorator[];
+    parameters: {
+        layout: string;
+        storePartial: {
+            viewPort?: {
+                isActive?: boolean;
+                configs?: {
+                    device?: import("../../lib/types/viewPort").TDevice;
+                    orientation?: import("../../lib/types/viewPort").TOrientation;
+                    width?: number;
+                    height?: number;
+                }[];
+                activeConfig?: {
+                    device?: import("../../lib/types/viewPort").TDevice;
+                    orientation?: import("../../lib/types/viewPort").TOrientation;
+                    width?: number;
+                    height?: number;
+                };
+                style?: {
+                    width?: number;
+                    height?: number;
+                    top?: number;
+                    left?: number;
+                    scale?: number;
+                    background?: string;
+                };
+                screen?: {
+                    orientation?: import("../../lib/types/viewPort").TOrientation;
+                    width?: number;
+                    height?: number;
+                };
+                device?: import("../../lib/types/viewPort").TDevice;
+                realDevice?: import("../../lib/types/viewPort").TDevice;
+                devicePixelRatio?: number;
+                userAgent?: {
+                    browser?: {
+                        isSafari?: boolean;
+                        isChrome?: boolean;
+                        ifFirefox?: boolean;
+                        isIE?: boolean;
+                        isOpera?: boolean;
+                    };
+                };
+            };
+            theme?: {
+                additional?: string;
+                buttonsStop0?: string;
+                buttonsStop1?: string;
+                additional2?: string;
+                bonusBet?: string;
+                bonusStop0?: string;
+                bonusStop1?: string;
+                bonusSecondaryStop0?: string;
+                bonusSecondaryStop1?: string;
+                mainUi?: string;
+            };
+            loading?: {
+                config?: {
+                    version?: `${import("../../../index").EVersion.default}`;
+                    customLogo?: string;
+                } | {
+                    version?: `${import("../../../index").EVersion.pro}`;
+                    logo?: string;
+                    customLogo?: string;
+                };
+                gameLoadingProgress?: number;
+                imagesLoadingProgress?: number;
+                areFontsLoaded?: boolean;
+                areTranslationsLoaded?: boolean;
+                isFinishedAnimation?: boolean;
+                isPreloadNonCriticalSuccess?: boolean;
+                isWaitingSuccess?: boolean;
+                isImagesLoadingFinished?: boolean;
+                isGameLoadingStarted?: boolean;
+                isLoadingAssetsPreloaded?: boolean;
+                nonCriticalImagesToLoad?: number;
+                nonCriticalImagesLoaded?: number;
+                nonCriticalImagesPaths?: string[];
+            };
+            welcome?: {
+                config?: {
+                    version?: `${import("../../../index").EWelcomeVersion.default}`;
+                    logo?: string;
+                    winUpTo?: number;
+                    slides?: {
+                        image?: string;
+                        title?: string;
+                        description?: string;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }[];
+                    background?: string | {
+                        portrait?: string;
+                        landscape?: string;
+                    };
+                    showVolatility?: boolean;
+                } | {
+                    version?: `${import("../../../index").EWelcomeVersion.grid}`;
+                    logo?: string;
+                    winUpTo?: number;
+                    slides?: [{
+                        image?: string;
+                        title?: string;
+                        description?: string;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }?, {
+                        image?: string;
+                        title?: string;
+                        description?: string;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }?] | [{
+                        image?: string;
+                        title?: string;
+                        description?: string;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }?, {
+                        image?: string;
+                        title?: string;
+                        description?: string;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }?, {
+                        image?: string;
+                        title?: string;
+                        description?: string;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }?];
+                    background?: string;
+                    showVolatility?: boolean;
+                } | {
+                    version?: `${import("../../../index").EWelcomeVersion.pro}`;
+                    showTapAnywhere?: boolean;
+                    showVolatility?: boolean;
+                };
+            };
+            apiConfig?: {
+                data?: {
+                    ok?: boolean;
+                    client?: unknown;
+                    localization?: {
+                        lang?: string;
+                        translations?: {
+                            [x: string]: string;
+                        };
+                    };
+                    game?: {
+                        gameTitle?: string;
+                        rtp?: number;
+                        volatility?: import("../../api/config/types").TVolatility;
+                        coinRatio?: number;
+                    };
+                    session?: {
+                        mode?: import("../../api/config").TSessionMode;
+                        social?: boolean;
+                        partner?: string;
+                        brand?: string;
+                        theme?: string;
+                        user?: string;
+                        bets?: {
+                            amount?: number;
+                            level?: number;
+                            default?: boolean;
+                        }[];
+                        stakeModes?: {
+                            name?: string;
+                            type?: import("../../../index").EStakeType;
+                            bets?: number;
+                            multiple?: boolean;
+                            parametric?: boolean;
+                            maxQty?: number;
+                        }[];
+                        currency?: string;
+                        currencyDecimals?: number;
+                        balance?: number;
+                        minBet?: number;
+                        maxBet?: number;
+                        maxExposure?: number;
+                        meta?: string;
+                        urls?: {
+                            lobby?: string;
+                            deposit?: string;
+                        };
+                        restore?: {
+                            roundId?: string;
+                            balanceInitial?: number;
+                            metaInitial?: string;
+                            stakes?: {
+                                amount?: number;
+                                name?: string;
+                                level?: number;
+                                params?: string;
+                            }[];
+                            responsesGS?: {
+                                response?: string;
+                                winCash?: number;
+                                winCoins?: number;
+                                meta?: string;
+                                choice?: number;
+                                choices?: number[];
+                                finished?: boolean;
+                            }[];
+                            netValue?: number;
+                        };
+                        prizeDrop?: {
+                            apiUrl?: string;
+                            token?: string;
+                            wallet?: boolean;
+                            rewardsHub?: boolean;
+                        };
+                    };
+                    compliance?: {
+                        licenseName?: string;
+                        minSpinTime?: number;
+                        fastPlayAvailable?: boolean;
+                        skipAvailable?: boolean;
+                        buyBonusAvailable?: boolean;
+                        showRTP?: boolean;
+                        showMaxPrize?: boolean;
+                        historyAvailable?: boolean;
+                        rulesAvailable?: boolean;
+                        autoplayAvailable?: boolean;
+                        autoplayInfinityAvailable?: boolean;
+                        autoplayMaxCount?: number;
+                        licenseShowAutoplayTotalBet?: boolean;
+                        autoBetLowering?: boolean;
+                        netPosition?: boolean;
+                        homeButtonAvailable?: boolean;
+                        celebrateLowWins?: boolean;
+                        licenseShowPaytableOnStart?: boolean;
+                    };
+                    promotools?: {
+                        balance?: number;
+                        count?: number;
+                        issued?: number;
+                        betIndex?: number;
+                        totalWon?: number;
+                        type?: "freerounds";
+                        uuid?: string;
+                        addWinnings?: boolean;
+                        level?: number;
+                    }[];
+                    promotoolsInitial?: {
+                        balance?: number;
+                        count?: number;
+                        issued?: number;
+                        betIndex?: number;
+                        totalWon?: number;
+                        type?: "freerounds";
+                        uuid?: string;
+                        addWinnings?: boolean;
+                        level?: number;
+                    }[];
+                    test?: boolean;
+                };
+                isPending?: boolean;
+                error?: {
+                    name?: string;
+                    message?: string;
+                };
+                fake?: {
+                    enabled?: boolean;
+                    delay?: number;
+                    response?: string;
+                    hasError?: boolean;
+                    error?: string;
+                };
+            };
+            stake?: {
+                current?: {
+                    amount?: number;
+                    name?: string;
+                    level?: number;
+                    params?: string;
+                };
+                default?: {
+                    amount?: number;
+                    name?: string;
+                    level?: number;
+                    params?: string;
+                };
+                stored?: {
+                    amount?: number;
+                    name?: string;
+                    level?: number;
+                    params?: string;
+                };
+                amountIndex?: number;
+                amountsMap?: {
+                    [x: string]: number[];
+                };
+                amountsMapByLevels?: {
+                    [x: number]: {
+                        [x: string]: number[];
+                    };
+                };
+                modes?: {
+                    name?: string;
+                    type?: import("../../../index").EStakeType;
+                    bets?: number;
+                    multiple?: boolean;
+                    parametric?: boolean;
+                    maxQty?: number;
+                }[];
+                levels?: number[];
+                stakeNameBeforeBuy?: string | null;
+            };
+            autoPlay?: {
+                isActive?: boolean;
+                isAvailable?: boolean;
+                lossLimitTotal?: number;
+                inProgress?: boolean;
+                activeNumber?: number;
+                startNumber?: number;
+                activeIndex?: number;
+                autospinNumbers?: number[];
+                defaultAutoSpinNumber?: number;
+                lossLimitsNumbers?: number[];
+                singleWinNumbers?: number[];
+                stopInBonusGame?: boolean;
+                lossLimit?: {
+                    active?: boolean;
+                    value?: number;
+                    customValue?: string;
+                };
+                singleWin?: {
+                    active?: boolean;
+                    value?: number;
+                    customValue?: string;
+                };
+                delay?: {
+                    default?: number;
+                    fastPlay?: number;
+                };
+            };
+            session?: {
+                isDemo?: boolean;
+                social?: boolean;
+                partner?: string;
+                balance?: number;
+                balancePrevious?: number;
+                netValue?: number;
+                netValuePrevious?: number;
+                shouldResetNetValue?: boolean;
+                currency?: string;
+                currencyDecimals?: number;
+                urls?: {
+                    lobby?: string;
+                    deposit?: string;
+                };
+                inactivityTimeout?: number;
+            };
+            modals?: {
+                hasOpened?: boolean;
+                current?: import("../../model/modals").TModalName[];
+                configs?: {
+                    menu?: {
+                        isPaytableVisible?: boolean;
+                        isGameInfoVisible?: boolean;
+                        isRoundsHistoryVisible?: boolean;
+                        isSettingsVisible?: boolean;
+                        isSoundsVisible?: boolean;
+                        isFastPlayVisible?: boolean;
+                        isFullScreenVisible?: boolean;
+                    };
+                };
+                isModalReady?: boolean;
+                serviceErrorName?: string;
+                serviceErrorMessage?: string;
+                serviceAutoplayType?: import("../../../entities/autoplay").TAutoplayServiceModalType;
+            };
+            app?: {
+                screen?: import("../../model/app/appSlice").TScreen;
+                isReplay?: boolean;
+                isUIHidden?: boolean;
+                isOffline?: boolean;
+                urlParams?: {
+                    isHomeButtonDisabled?: boolean;
+                };
+                env?: {
+                    isDev?: boolean;
+                    isStaging?: boolean;
+                    isProd?: boolean;
+                };
+                error?: {
+                    name?: string;
+                    message?: string;
+                    code?: number;
+                };
+                isTestAvailable?: boolean;
+                test?: string;
+                isUIFrozen?: boolean;
+                isIframe?: boolean;
+                isBonusActive?: boolean;
+                tapAnywhere?: {
+                    enabled?: boolean;
+                    type?: import("../../model/app/appSlice").TTapAnywhereType;
+                    autocloseDelay?: number;
+                };
+                startSessionTime?: number;
+                playerPanelTransparent?: boolean;
+                modulesConfig?: {
+                    promoLobby?: {
+                        enabled?: boolean;
+                        wallet?: boolean;
+                        rewardsHub?: boolean;
+                        lang?: string;
+                        url?: string;
+                        token?: string;
+                        fakeApi?: {
+                            prizeDropLobbyInit?: {
+                                enabled?: boolean;
+                                delay?: number;
+                                response?: string;
+                                hasError?: boolean;
+                                error?: string;
+                            };
+                            prizeDropJoinCampaign?: {
+                                enabled?: boolean;
+                                delay?: number;
+                                countRetries?: number;
+                                response?: string;
+                                hasError?: boolean;
+                                error?: string;
+                            };
+                            rewardsList?: {
+                                enabled?: boolean;
+                                delay?: number;
+                                response?: string;
+                                hasError?: boolean;
+                                error?: string;
+                            };
+                            rewardsClaim?: {
+                                enabled?: boolean;
+                                delay?: number;
+                                countRetries?: number;
+                                response?: string;
+                                hasError?: boolean;
+                                error?: string;
+                            };
+                            exchangeRate?: {
+                                enabled?: boolean;
+                                delay?: number;
+                                response?: string;
+                                hasError?: boolean;
+                                error?: string;
+                            };
+                            walletTransactions?: {
+                                enabled?: boolean;
+                                delay?: number;
+                                response?: string;
+                                hasError?: boolean;
+                                error?: string;
+                                errorWhenScroll?: boolean;
+                            };
+                            walletConvert?: {
+                                enabled?: boolean;
+                                delay?: number;
+                                response?: string;
+                                hasError?: boolean;
+                                error?: string;
+                            };
+                        };
+                        fakeSocket?: {
+                            enabled?: boolean;
+                            delay?: number;
+                            hasError?: boolean;
+                            error?: string;
+                        };
+                    };
+                    externalUI?: {
+                        enabled?: boolean;
+                    };
+                };
+                modulesRuntime?: {
+                    promoLobby?: {
+                        blocksGameplayInput?: boolean;
+                    };
+                };
+            };
+            initResponse?: {
+                data?: {
+                    mode?: import("../../../shared/lib/singletones/gameEmitter").TInitMode;
+                    client?: unknown;
+                    localization?: {
+                        lang?: string;
+                        translations?: {
+                            [x: string]: string;
+                        };
+                    };
+                    test?: boolean;
+                    session?: {
+                        theme?: string;
+                        social?: boolean;
+                        currency?: string;
+                        currencyDecimals?: number;
+                    };
+                    stake?: {
+                        current?: {
+                            amount?: number;
+                            name?: string;
+                            level?: number;
+                            params?: string;
+                        };
+                        default?: {
+                            amount?: number;
+                            name?: string;
+                            level?: number;
+                            params?: string;
+                        };
+                        amount?: number;
+                        name?: string;
+                        level?: number;
+                        params?: string;
+                    };
+                    stakeResponse?: {
+                        current?: {
+                            amount?: number;
+                            name?: string;
+                            level?: number;
+                            params?: string;
+                        };
+                        default?: {
+                            amount?: number;
+                            name?: string;
+                            level?: number;
+                            params?: string;
+                        };
+                        amount?: number;
+                        name?: string;
+                        level?: number;
+                        params?: string;
+                    };
+                    stakeLevels?: number[];
+                    sound?: {
+                        isActive?: boolean;
+                        volume?: number;
+                        effects?: number;
+                        music?: number;
+                    };
+                    compliance?: {
+                        minSpinTime?: number;
+                        celebrateLowWins?: boolean;
+                        showRTP?: boolean;
+                        buyBonusAvailable?: boolean;
+                        fastPlayAvailable?: boolean;
+                        autoplayAvailable?: boolean;
+                        netPosition?: boolean;
+                    };
+                    modules?: {
+                        externalUI?: {
+                            mainScreenID?: string;
+                            compliance?: {
+                                licenseName?: string;
+                                skipAvailable?: boolean;
+                                autoplayInfinityAvailable?: boolean;
+                                autoplayMaxCount?: number;
+                            };
+                            stakeData?: {
+                                modes?: {
+                                    name?: string;
+                                    type?: import("../../../index").EStakeType;
+                                    bets?: number;
+                                    multiple?: boolean;
+                                    parametric?: boolean;
+                                    maxQty?: number;
+                                }[];
+                                amountsMap?: {
+                                    [x: string]: number[];
+                                };
+                                amountsMapByLevels?: {
+                                    [x: number]: {
+                                        [x: string]: number[];
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            sound?: {
+                isActive?: boolean;
+                isDragging?: boolean;
+                isChangedByUser?: boolean;
+                lastOffParam?: "effects" | "music" | null;
+                volume?: {
+                    current?: number;
+                    store?: number;
+                };
+                effects?: {
+                    current?: number;
+                    store?: number;
+                };
+                music?: {
+                    current?: number;
+                    store?: number;
+                };
+            };
+            play?: {
+                isActive?: boolean;
+                isWaitingForChoice?: boolean;
+            };
+            apiRoundOpen?: {
+                data?: {
+                    roundId?: string;
+                    balance?: number;
+                    responseGS?: {
+                        response?: string;
+                        winCash?: number;
+                        winCoins?: number;
+                        meta?: string;
+                        choice?: number;
+                        choices?: number[];
+                        finished?: boolean;
+                    };
+                    promotools?: {
+                        balance?: number;
+                        count?: number;
+                        issued?: number;
+                        betIndex?: number;
+                        totalWon?: number;
+                        type?: "freerounds";
+                        uuid?: string;
+                        addWinnings?: boolean;
+                        level?: number;
+                    }[];
+                    meta?: unknown;
+                };
+                payload?: {
+                    stakes?: {
+                        amount?: number;
+                        name?: string;
+                        level?: number;
+                        params?: string;
+                    }[];
+                    analytics?: string;
+                    test?: string;
+                    pdCampaignId?: string;
+                    betIndex?: number;
+                    balance?: number;
+                    currency?: string;
+                    meta?: unknown;
+                    pdConvertRewardId?: string;
+                };
+                isPending?: boolean;
+                error?: {
+                    name?: string;
+                    message?: string;
+                };
+                fake?: {
+                    enabled?: boolean;
+                    delay?: number;
+                    response?: string;
+                    hasError?: boolean;
+                    error?: string;
+                };
+            };
+            fastPlay?: {
+                mode?: import("../../../entities/fastplay").TFastPlayMode;
+                isEnabled?: boolean;
+            };
+            bonus?: {
+                modes?: {
+                    name?: string;
+                    title?: string;
+                    description?: import("../../model/bonus").TBonusDescription;
+                    imageCard?: string;
+                    imageConfirm?: string;
+                }[];
+                bonusBetModes?: {
+                    bonus?: {
+                        name?: string;
+                        title?: string;
+                        description?: import("../../model/bonus").TBonusDescription;
+                        imageCard?: string;
+                        imageConfirm?: string;
+                    };
+                    stake?: {
+                        name?: string;
+                        type?: import("../../../index").EStakeType;
+                        bets?: number;
+                        multiple?: boolean;
+                        parametric?: boolean;
+                        maxQty?: number;
+                    };
+                }[];
+                buyModes?: {
+                    bonus?: {
+                        name?: string;
+                        title?: string;
+                        description?: import("../../model/bonus").TBonusDescription;
+                        imageCard?: string;
+                        imageConfirm?: string;
+                    };
+                    stake?: {
+                        name?: string;
+                        type?: import("../../../index").EStakeType;
+                        bets?: number;
+                        multiple?: boolean;
+                        parametric?: boolean;
+                        maxQty?: number;
+                    };
+                }[];
+                hasBonusGame?: boolean;
+                currentModeNames?: string[];
+                selectedModeName?: string | null;
+                preselectedModeName?: string | null;
+                customBonusBets?: boolean;
+                tmpLevel?: number | null;
+                tmpAmountIndex?: number | null;
+                maxBonusCards?: number;
+            };
+            realityCheck?: {
+                isActive?: boolean;
+                isActiveToggle?: boolean;
+                isActiveReminder?: boolean;
+                isPausedActive?: boolean;
+                timeValues?: number[];
+                repeatTimeValues?: number[];
+                hasDeferred?: boolean;
+                startRepeatReminderTime?: number;
+                startReminderTime?: number;
+                delayTime?: number;
+                reminderTime?: {
+                    new?: {
+                        value?: number;
+                        customValue?: number;
+                    };
+                    current?: {
+                        value?: number;
+                        customValue?: number;
+                    };
+                };
+                repeatReminderTime?: {
+                    new?: {
+                        value?: number;
+                        customValue?: number;
+                    };
+                    current?: {
+                        value?: number;
+                        customValue?: number;
+                    };
+                };
+            };
+            skip?: {
+                isEnabled?: boolean;
+                isTurboActive?: boolean;
+                turboFromHold?: boolean;
+                turboRoundsDelay?: number;
+                turboSkipDelay?: number;
+                turboEnabled?: boolean;
+                holdForTurboShown?: boolean;
+                holdForTurboAvailable?: boolean;
+                holdForTurboEnabled?: boolean;
+                countHoldForTurbo?: number;
+                wasHoldOnce?: boolean;
+            };
+            round?: {
+                roundId?: string;
+                meta?: unknown;
+                responsesGS?: {
+                    response?: string;
+                    winCash?: number;
+                    winCoins?: number;
+                    meta?: string;
+                    choice?: number;
+                    choices?: number[];
+                    finished?: boolean;
+                }[];
+                isRestore?: boolean;
+                wasRestore?: boolean;
+                hasMaxWin?: boolean;
+                current?: {
+                    responseGS?: {
+                        response?: string;
+                        winCash?: number;
+                        winCoins?: number;
+                        meta?: string;
+                        choice?: number;
+                        choices?: number[];
+                        finished?: boolean;
+                    };
+                    responseGSIndex?: number;
+                    isFinished?: boolean;
+                    win?: {
+                        winCash?: number;
+                        mode?: "single" | "total";
+                        animate?: boolean;
+                    };
+                    choice?: number;
+                };
+                final?: {
+                    balance?: number;
+                    winCash?: number;
+                };
+            };
+            panel?: {
+                config?: {
+                    version?: `${import("../../../index").EVersion.default}`;
+                    disableSkipButton?: boolean;
+                } | {
+                    version?: "pro";
+                    disableSkipButton?: boolean;
+                    play?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                    stop?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                    playBonus?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                    stopBonus?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                    autoPlayStart?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                    stakeAmounts?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                    fastPlayOn?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                    fastPlayOff?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                    autoPlayOn?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                    autoPlayOff?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                    menu?: {
+                        default?: string;
+                        hover?: string;
+                        onTap?: string;
+                        disabled?: string;
+                    };
+                };
+                counterData?: {
+                    count?: number;
+                    type?: import("../../model/panels").TPanelCounterType;
+                    title?: string;
+                    total?: number;
+                    animate?: boolean;
+                };
+                enabled?: boolean;
+            };
+            playerPanel?: {
+                showTotalWin?: boolean;
+            };
+            localization?: {
+                lang?: string;
+                translations?: {
+                    [x: string]: string;
+                };
+            };
+            payTable?: {
+                containers?: ({
+                    type?: import("../../../entities/payTable").TPayTableTitle["type"];
+                    items?: {
+                        type?: "title";
+                        text?: string;
+                    }[];
+                } | {
+                    type?: import("../../../entities/payTable").TPayTableSeparator["type"];
+                    items?: {
+                        type?: "separator";
+                    }[];
+                } | {
+                    type?: import("../../../entities/payTable").TPayTableSymbolSpecialV1["type"];
+                    items?: {
+                        type?: "symbol-special-v1";
+                        img?: string;
+                        title?: string;
+                        description?: string;
+                        settings?: {
+                            type?: "default";
+                            content?: {
+                                count?: number | string;
+                                bets?: number;
+                            }[];
+                        } | {
+                            type?: "custom";
+                            content?: import("../../../entities/payTable").TSymbolSettingsCustomContent[];
+                        } | {
+                            type?: "dynamic";
+                            content?: {
+                                count?: number | string;
+                                coins?: number;
+                            }[];
+                        };
+                        lineBreak?: boolean;
+                    }[];
+                } | {
+                    type?: import("../../../entities/payTable").TPayTableSymbolSpecialV2["type"];
+                    items?: {
+                        type?: "symbol-special-v2";
+                        img?: string;
+                        title?: string;
+                        description?: string;
+                        settings?: {
+                            type?: "default";
+                            content?: {
+                                count?: number | string;
+                                bets?: number;
+                            }[];
+                        } | {
+                            type?: "custom";
+                            content?: import("../../../entities/payTable").TSymbolSettingsCustomContent[];
+                        } | {
+                            type?: "dynamic";
+                            content?: {
+                                count?: number | string;
+                                coins?: number;
+                            }[];
+                        };
+                        lineBreak?: boolean;
+                    }[];
+                } | {
+                    type?: import("../../../entities/payTable").TPayTableSymbolGridV1["type"];
+                    items?: {
+                        type?: "symbol-grid-v1";
+                        img?: string;
+                        settings?: {
+                            type?: "default";
+                            content?: {
+                                count?: number | string;
+                                bets?: number;
+                            }[];
+                        } | {
+                            type?: "custom";
+                            content?: import("../../../entities/payTable").TSymbolSettingsCustomContent[];
+                        } | {
+                            type?: "dynamic";
+                            content?: {
+                                count?: number | string;
+                                coins?: number;
+                            }[];
+                        };
+                        lineBreak?: boolean;
+                    }[];
+                } | {
+                    type?: import("../../../entities/payTable").TPayTableLine["type"];
+                    items?: {
+                        type?: "lines";
+                        rows?: number;
+                        values?: number[];
+                        lineBreak?: boolean;
+                    }[];
+                })[];
+                symbolsGridV1Gap?: import("../../../entities/payTable").TSymbolsGridV1Gap;
+                background?: string | {
+                    portrait?: string;
+                    landscape?: string;
+                };
+            };
+            apiRoundClose?: {
+                data?: {
+                    ok?: boolean;
+                };
+                isPending?: boolean;
+                error?: {
+                    name?: string;
+                    message?: string;
+                };
+                fake?: {
+                    enabled?: boolean;
+                    delay?: number;
+                    response?: string;
+                    hasError?: boolean;
+                    error?: string;
+                };
+            };
+            roundsHistory?: {
+                isPending?: boolean;
+                error?: {
+                    name?: string;
+                    message?: string;
+                };
+                rounds?: {
+                    roundId?: string;
+                    date?: string;
+                    bet?: number;
+                    win?: number;
+                    xbet?: number;
+                    replayUrl?: string;
+                    balance?: number;
+                }[];
+                selectedRoundUUID?: string;
+                replayRound?: {
+                    date?: string;
+                    replayUrl?: string;
+                    bet?: number;
+                    win?: number;
+                };
+                replayStatus?: "start" | "end";
+                fake?: {
+                    enabled?: boolean;
+                    delay?: number;
+                    response?: string;
+                    hasError?: boolean;
+                    error?: string;
+                };
+            };
+            gameInfo?: {
+                deferredConfig?: {
+                    items?: ({
+                        type?: "title";
+                        text?: string;
+                    } | {
+                        type?: "symbol-special-v1";
+                        img?: string;
+                        title?: string;
+                        description?: string;
+                        settings?: {
+                            type?: "default";
+                            content?: {
+                                count?: number | string;
+                                bets?: number;
+                            }[];
+                        } | {
+                            type?: "custom";
+                            content?: import("../../../entities/payTable").TSymbolSettingsCustomContent[];
+                        } | {
+                            type?: "dynamic";
+                            content?: {
+                                count?: number | string;
+                                coins?: number;
+                            }[];
+                        };
+                        lineBreak?: boolean;
+                    } | {
+                        type?: "symbol-special-v2";
+                        img?: string;
+                        title?: string;
+                        description?: string;
+                        settings?: {
+                            type?: "default";
+                            content?: {
+                                count?: number | string;
+                                bets?: number;
+                            }[];
+                        } | {
+                            type?: "custom";
+                            content?: import("../../../entities/payTable").TSymbolSettingsCustomContent[];
+                        } | {
+                            type?: "dynamic";
+                            content?: {
+                                count?: number | string;
+                                coins?: number;
+                            }[];
+                        };
+                        lineBreak?: boolean;
+                    } | {
+                        type?: "symbol-grid-v1";
+                        img?: string;
+                        settings?: {
+                            type?: "default";
+                            content?: {
+                                count?: number | string;
+                                bets?: number;
+                            }[];
+                        } | {
+                            type?: "custom";
+                            content?: import("../../../entities/payTable").TSymbolSettingsCustomContent[];
+                        } | {
+                            type?: "dynamic";
+                            content?: {
+                                count?: number | string;
+                                coins?: number;
+                            }[];
+                        };
+                        lineBreak?: boolean;
+                    } | {
+                        type?: "lines";
+                        rows?: number;
+                        values?: number[];
+                        lineBreak?: boolean;
+                    } | {
+                        type?: "separator";
+                    } | {
+                        type?: "feature-v1";
+                        alignment?: `${import("../InfoConstructor").EFeatureAlignmentV1Type}`;
+                        img?: string;
+                        title?: string;
+                        description?: string;
+                        lineBreak?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    } | {
+                        type?: "feature-v2";
+                        img?: string;
+                        width?: `${import("../InfoConstructor").EFeatureWidthV2Type}`;
+                        title?: string;
+                        description?: string;
+                        lineBreak?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    } | {
+                        type?: "icon-list-item";
+                        icon?: import("../InfoConstructor").TInfoIconName;
+                        text?: string;
+                        isHidden?: boolean;
+                    } | {
+                        type?: "list-item";
+                        text?: string;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    } | {
+                        type?: "text";
+                        text?: string;
+                        dangerouslySetInnerHTML?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    } | {
+                        type?: "subtitle";
+                        text?: string;
+                        noMargin?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    } | {
+                        type?: "table-cell";
+                        values?: [string?, string?];
+                        equalWidthColumns?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    } | {
+                        type?: "table-head";
+                        values?: [string?, string?];
+                        equalWidthColumns?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    } | {
+                        type?: "title";
+                        text?: string;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    } | {
+                        type?: "separator";
+                        size?: "default" | "small";
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    })[];
+                    version?: string;
+                    lastUpdate?: string;
+                    background?: string | {
+                        portrait?: string;
+                        landscape?: string;
+                    };
+                    preset?: {
+                        name?: "truelab-game";
+                        version?: string;
+                        lastUpdate?: string;
+                    };
+                    symbolsGridV1Gap?: import("../../../entities/payTable").TSymbolsGridV1Gap;
+                };
+                containers?: ({
+                    type?: import("../../../entities/payTable").TPayTableTitle["type"];
+                    items?: {
+                        type?: "title";
+                        text?: string;
+                    }[];
+                } | {
+                    type?: import("../../../entities/payTable").TPayTableSeparator["type"];
+                    items?: {
+                        type?: "separator";
+                    }[];
+                } | {
+                    type?: import("../../../entities/payTable").TPayTableSymbolSpecialV1["type"];
+                    items?: {
+                        type?: "symbol-special-v1";
+                        img?: string;
+                        title?: string;
+                        description?: string;
+                        settings?: {
+                            type?: "default";
+                            content?: {
+                                count?: number | string;
+                                bets?: number;
+                            }[];
+                        } | {
+                            type?: "custom";
+                            content?: import("../../../entities/payTable").TSymbolSettingsCustomContent[];
+                        } | {
+                            type?: "dynamic";
+                            content?: {
+                                count?: number | string;
+                                coins?: number;
+                            }[];
+                        };
+                        lineBreak?: boolean;
+                    }[];
+                } | {
+                    type?: import("../../../entities/payTable").TPayTableSymbolSpecialV2["type"];
+                    items?: {
+                        type?: "symbol-special-v2";
+                        img?: string;
+                        title?: string;
+                        description?: string;
+                        settings?: {
+                            type?: "default";
+                            content?: {
+                                count?: number | string;
+                                bets?: number;
+                            }[];
+                        } | {
+                            type?: "custom";
+                            content?: import("../../../entities/payTable").TSymbolSettingsCustomContent[];
+                        } | {
+                            type?: "dynamic";
+                            content?: {
+                                count?: number | string;
+                                coins?: number;
+                            }[];
+                        };
+                        lineBreak?: boolean;
+                    }[];
+                } | {
+                    type?: import("../../../entities/payTable").TPayTableSymbolGridV1["type"];
+                    items?: {
+                        type?: "symbol-grid-v1";
+                        img?: string;
+                        settings?: {
+                            type?: "default";
+                            content?: {
+                                count?: number | string;
+                                bets?: number;
+                            }[];
+                        } | {
+                            type?: "custom";
+                            content?: import("../../../entities/payTable").TSymbolSettingsCustomContent[];
+                        } | {
+                            type?: "dynamic";
+                            content?: {
+                                count?: number | string;
+                                coins?: number;
+                            }[];
+                        };
+                        lineBreak?: boolean;
+                    }[];
+                } | {
+                    type?: import("../../../entities/payTable").TPayTableLine["type"];
+                    items?: {
+                        type?: "lines";
+                        rows?: number;
+                        values?: number[];
+                        lineBreak?: boolean;
+                    }[];
+                } | {
+                    type?: import("../InfoConstructor/items/InfoTitle").TInfoTitle["type"];
+                    items?: {
+                        type?: "title";
+                        text?: string;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }[];
+                } | {
+                    type?: import("../InfoConstructor").TInfoFeatureV1["type"];
+                    items?: {
+                        type?: "feature-v1";
+                        alignment?: `${import("../InfoConstructor").EFeatureAlignmentV1Type}`;
+                        img?: string;
+                        title?: string;
+                        description?: string;
+                        lineBreak?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }[];
+                } | {
+                    type?: import("../InfoConstructor").TInfoFeatureV2["type"];
+                    items?: {
+                        type?: "feature-v2";
+                        img?: string;
+                        width?: `${import("../InfoConstructor").EFeatureWidthV2Type}`;
+                        title?: string;
+                        description?: string;
+                        lineBreak?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }[];
+                } | {
+                    type?: import("../InfoConstructor").TInfoSeparator["type"];
+                    items?: {
+                        type?: "separator";
+                        size?: "default" | "small";
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }[];
+                } | {
+                    type?: import("../InfoConstructor/items/InfoSubTitle").TInfoSubTitle["type"];
+                    items?: {
+                        type?: "subtitle";
+                        text?: string;
+                        noMargin?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }[];
+                } | {
+                    type?: import("../InfoConstructor/items/InfoText").TInfoText["type"];
+                    items?: {
+                        type?: "text";
+                        text?: string;
+                        dangerouslySetInnerHTML?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }[];
+                } | {
+                    type?: import("../InfoConstructor").TInfoListItem["type"];
+                    items?: {
+                        type?: "list-item";
+                        text?: string;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }[];
+                } | {
+                    type?: import("../InfoConstructor").TInfoIconListItem["type"];
+                    items?: {
+                        type?: "icon-list-item";
+                        icon?: import("../InfoConstructor").TInfoIconName;
+                        text?: string;
+                        isHidden?: boolean;
+                    }[];
+                } | {
+                    type?: import("../InfoConstructor/items/InfoTableHead").TInfoTableHead["type"];
+                    items?: {
+                        type?: "table-head";
+                        values?: [string?, string?];
+                        equalWidthColumns?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }[];
+                } | {
+                    type?: import("../InfoConstructor/items/InfoTableCell").TInfoTableCell["type"];
+                    items?: {
+                        type?: "table-cell";
+                        values?: [string?, string?];
+                        equalWidthColumns?: boolean;
+                        isHidden?: boolean;
+                        compliance?: {
+                            isHidden?: boolean;
+                            isBuyBonusInfo?: boolean;
+                            isDesktopInfo?: boolean;
+                            isAutoPlayInfo?: boolean;
+                            isFastPlayInfo?: boolean;
+                        };
+                    }[];
+                })[];
+                symbolsGridV1Gap?: import("../../../entities/payTable").TSymbolsGridV1Gap;
+                background?: string | {
+                    portrait?: string;
+                    landscape?: string;
+                };
+                preset?: {
+                    name?: "truelab-game";
+                    version?: string;
+                    lastUpdate?: string;
+                };
+            };
+            apiRoundPlay?: {
+                data?: {
+                    meta?: unknown;
+                    roundId?: string;
+                    responseGS?: {
+                        response?: string;
+                        winCash?: number;
+                        winCoins?: number;
+                        meta?: string;
+                        choice?: number;
+                        choices?: number[];
+                        finished?: boolean;
+                    };
+                    promotools?: {
+                        balance?: number;
+                        count?: number;
+                        issued?: number;
+                        betIndex?: number;
+                        totalWon?: number;
+                        type?: "freerounds";
+                        uuid?: string;
+                        addWinnings?: boolean;
+                        level?: number;
+                    }[];
+                };
+                isPending?: boolean;
+                error?: {
+                    name?: string;
+                    message?: string;
+                };
+                fake?: {
+                    enabled?: boolean;
+                    delay?: number;
+                    response?: string;
+                    hasError?: boolean;
+                    error?: string;
+                    responseIndex?: number;
+                };
+            };
+            freeRounds?: {
+                isActive?: boolean;
+                displayCount?: number;
+                displayTotalWon?: number;
+                current?: {
+                    balance?: number;
+                    count?: number;
+                    issued?: number;
+                    betIndex?: number;
+                    totalWon?: number;
+                    type?: "freerounds";
+                    uuid?: string;
+                    addWinnings?: boolean;
+                    level?: number;
+                };
+                initial?: {
+                    balance?: number;
+                    count?: number;
+                    issued?: number;
+                    betIndex?: number;
+                    totalWon?: number;
+                    type?: "freerounds";
+                    uuid?: string;
+                    addWinnings?: boolean;
+                    level?: number;
+                };
+                version?: `${import("../../../index").EVersion}`;
+            };
+            apiRoundReplay?: {
+                data?: {
+                    ok?: boolean;
+                    client?: unknown;
+                    localization?: {
+                        lang?: string;
+                        translations?: {
+                            [x: string]: string;
+                        };
+                    };
+                    game?: {
+                        gameTitle?: string;
+                        rtp?: number;
+                        volatility?: import("../../api/config/types").TVolatility;
+                        coinRatio?: number;
+                    };
+                    session?: {
+                        theme?: string;
+                        social?: boolean;
+                        partner?: string;
+                        currency?: string;
+                        currencyDecimals?: number;
+                        urls?: {
+                            lobby?: string;
+                            deposit?: string;
+                        };
+                        prizeDrop?: {
+                            apiUrl?: string;
+                            token?: string;
+                            wallet?: boolean;
+                            rewardsHub?: boolean;
+                        };
+                        meta?: string;
+                        mode?: import("../../api/config").TSessionMode;
+                        brand?: string;
+                        user?: string;
+                        bets?: {
+                            amount?: number;
+                            level?: number;
+                            default?: boolean;
+                        }[];
+                        stakeModes?: {
+                            name?: string;
+                            type?: import("../../../index").EStakeType;
+                            bets?: number;
+                            multiple?: boolean;
+                            parametric?: boolean;
+                            maxQty?: number;
+                        }[];
+                        minBet?: number;
+                        maxBet?: number;
+                        maxExposure?: number;
+                        replay?: {
+                            roundId?: string;
+                            balanceInitial?: number;
+                            metaInitial?: string;
+                            stakes?: {
+                                amount?: number;
+                                name?: string;
+                                level?: number;
+                                params?: string;
+                            }[];
+                            responsesGS?: {
+                                response?: string;
+                                winCash?: number;
+                                winCoins?: number;
+                                meta?: string;
+                                choice?: number;
+                                choices?: number[];
+                                finished?: boolean;
+                            }[];
+                            date?: string;
+                            replayUrl?: string;
+                        };
+                    };
+                    compliance?: {
+                        licenseName?: string;
+                        minSpinTime?: number;
+                        fastPlayAvailable?: boolean;
+                        skipAvailable?: boolean;
+                        buyBonusAvailable?: boolean;
+                        showRTP?: boolean;
+                        showMaxPrize?: boolean;
+                        historyAvailable?: boolean;
+                        rulesAvailable?: boolean;
+                        autoplayAvailable?: boolean;
+                        autoplayInfinityAvailable?: boolean;
+                        autoplayMaxCount?: number;
+                        licenseShowAutoplayTotalBet?: boolean;
+                        autoBetLowering?: boolean;
+                        netPosition?: boolean;
+                        homeButtonAvailable?: boolean;
+                        celebrateLowWins?: boolean;
+                        licenseShowPaytableOnStart?: boolean;
+                    };
+                };
+                isPending?: boolean;
+                error?: {
+                    name?: string;
+                    message?: string;
+                };
+                fake?: {
+                    enabled?: boolean;
+                    delay?: number;
+                    response?: string;
+                    hasError?: boolean;
+                    error?: string;
+                };
+            };
+            gameSettings?: {
+                gameTitle?: string;
+                rtp?: number;
+                volatility?: import("../../api/config/types").TVolatility;
+                coinRatio?: number;
+            };
+            complianceSettings?: {
+                licenseName?: string;
+                minSpinTime?: number;
+                fastPlayAvailable?: boolean;
+                skipAvailable?: boolean;
+                buyBonusAvailable?: boolean;
+                showRTP?: boolean;
+                showMaxPrize?: boolean;
+                historyAvailable?: boolean;
+                rulesAvailable?: boolean;
+                autoplayAvailable?: boolean;
+                autoplayInfinityAvailable?: boolean;
+                autoplayMaxCount?: number;
+                licenseShowAutoplayTotalBet?: boolean;
+                autoBetLowering?: boolean;
+                netPosition?: boolean;
+                homeButtonAvailable?: boolean;
+                celebrateLowWins?: boolean;
+                licenseShowPaytableOnStart?: boolean;
+            };
+            topLine?: {
+                config?: {
+                    payout?: {
+                        type?: `${import("../../../index").EPayoutType}`;
+                        count?: number;
+                    };
+                    showRTP?: boolean;
+                    customLogo?: string;
+                };
+            };
+            appearance?: {
+                loadingSpinner?: import("../../model/appearance").TLoadingSpinner;
+            };
+            fillFrame?: {
+                config?: {
+                    enabled?: boolean;
+                    portrait?: {
+                        width?: number;
+                        height?: number;
+                    };
+                    landscape?: {
+                        width?: number;
+                        height?: number;
+                    };
+                };
+            };
+            meetUi?: {
+                config?: {
+                    enabled?: boolean;
+                    isBuyFeatureSupported?: boolean;
+                    isAutoPlaySupported?: boolean;
+                    isFastPlaySupported?: boolean;
+                    expiredDate?: string;
+                };
+                showed?: boolean;
+            };
+            menu?: {
+                activeTab?: import("../../../entities/menu").TMenuTab;
+                isTabBarHidden?: boolean;
+                entry?: import("../../../entities/menu").TMenuEntry;
+            };
+            _persist?: {
+                version?: number;
+                rehydrated?: boolean;
+            };
+        };
+    };
+    args: {
+        children: import("react/jsx-runtime").JSX.Element;
+    };
+};
+export default meta;
+type TStory = StoryObj<typeof meta>;
+export declare const PortraitBar: TStory;
+export declare const LandscapeBar: TStory;
+/** The highlight is placed from the tab index, so every position is worth a look */
+export declare const ActivePositionsPortrait: TStory;
+export declare const ActivePositionsLandscape: TStory;
+/** Hover cannot be captured in a screenshot — check it in the browser */
+export declare const ItemStates: TStory;
+/** Soc-casino and sweepstakes builds run without the promoLobby module: the bar is just shorter */
+export declare const WithoutPromoLobbyTab: TStory;
+/** The active tab is tinted from the game palette, not from a fixed brand color */
+export declare const AccentColor: TStory;