@truelab/truelogic-plinko 0.0.1-0

package/dist/types/src/shared/lib/tests/utils/setupTestStore.d.ts

@@ -0,0 +1,691 @@
+export declare const setupTestStore: (storePartial?: DeepPartial<TRootState>) => import("@reduxjs/toolkit").EnhancedStore<{
+    viewPort: import("../../../viewPort/lib/types").TViewPortState;
+    loading: {
+        config: import("../../../model/loading").TLoadingConfig;
+        gameLoadingProgress: number;
+        imagesLoadingProgress: number;
+        areFontsLoaded: boolean;
+        areTranslationsLoaded: boolean;
+        isFinishedAnimation: boolean;
+        isPreloadNonCriticalSuccess: boolean;
+        isPreloadPanelSuccess: boolean;
+        isWaitingSuccess: boolean;
+        isImagesLoadingFinished: boolean;
+        isGameLoadingStarted: boolean;
+        isLoadingAssetsPreloaded: boolean;
+        nonCriticalImagesToLoad: number;
+        nonCriticalImagesLoaded: number;
+        panelImagesToLoad: number;
+        panelImagesLoaded: number;
+    };
+    welcome: {
+        config: import("../../../model/welcome").TWelcomeConfig;
+    };
+    apiConfig: import("../../../../app/config/types/apiConfig").TApiConfigState;
+    stake: import("../../../../entities/stake/model/stakeSlice").TStakeState;
+    autoPlay: {
+        isActive: boolean;
+        isAvailable?: boolean;
+        lossLimitTotal: number;
+        inProgress: boolean;
+        isVisibleDropdown: 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;
+        partner: string;
+        balance: number;
+        balancePrevious: number;
+        netValue: number;
+        netValuePrevious: number;
+        shouldResetNetValue: boolean;
+        currency: string;
+        currencyDecimals: number;
+        urls: import("../../../api/config/types").TSessionUrls;
+    };
+    modals: {
+        hasOpened: boolean;
+        current: import("../../../model/modals").TModalName[];
+        configs: {
+            menu: import("../../../model/menu").TMenuConfig;
+        };
+        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: import("../../../model/app").TAppError;
+        isTestAvailable: boolean;
+        test: string;
+        isUIFrozen: boolean;
+        isIframe: boolean;
+        isBonusActive: boolean;
+        tapAnywhere: {
+            enabled: boolean;
+            type: import("../../../model/app/appSlice").TTapAnywhereType;
+            autocloseDelay: number;
+        };
+        startSessionTime?: 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;
+    };
+    apiRoundOpen: {
+        data: import("../../../api/round/open").TApiRoundOpenResponse;
+        isPending: boolean;
+        error: {
+            name: string;
+            message: string;
+        };
+        fake: import("../../../api/round/open").TApiRoundOpenFake;
+    };
+    fastPlay: {
+        isActive: boolean;
+    };
+    bonus: {
+        modes: import("../../../model/bonus").TBonusModes;
+        hasBonusGame: boolean;
+        currentModeNames: string[];
+        selectedModeName: string;
+        preselectedModeName: string;
+        isConfirmModalShown: boolean;
+        tmpLevel: number;
+        tmpAmountIndex: number;
+        activeSlideWidth: number;
+        activeSlideOffsetX: number;
+        isSliderInTransition: boolean;
+        isSliderInSwiping: boolean;
+        isOutsideViewportCardSelected: boolean;
+        isLastSlideOutOfView: boolean;
+    };
+    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;
+        turboRoundsDelay: number;
+        turboSkipDelay: number;
+        isTooltipActive: boolean;
+        shouldOpenTooltip: boolean;
+        tooltipCheckpoint: number;
+        isSkipCounterEnabled: boolean;
+        skipCounter: number;
+    };
+    round: {
+        roundId: string;
+        meta?: unknown;
+        responsesGS: import("../../../../truelogic").TResponseGS[];
+        isRestore: boolean;
+        wasRestore: boolean;
+        hasMaxWin: boolean;
+        current: {
+            responseGS: import("../../../../truelogic").TResponseGS;
+            responseGSIndex: number;
+            isFinished: boolean;
+            win: import("../../../../entities/round").TWin;
+            choice?: number;
+        };
+        final: {
+            balance: number;
+            winCash: number;
+        };
+    };
+    panel: {
+        config: import("../../../model/panels").TPanelConfig;
+        counterData: import("../../../model/panels").TPanelCounterData;
+    };
+    localization: import("../../../localization").TLocalizationSettings;
+    payTable: {
+        containers: import("../../../../entities/payTable").TPayTableContainer[];
+        symbolsGridV1Gap: import("../../../../entities/payTable").TSymbolsGridV1Gap;
+        background?: string | {
+            portrait?: string;
+            landscape?: string;
+        };
+    };
+    apiRoundClose: {
+        data: import("../../../api/round/close").TApiRoundCloseResponse;
+        isPending: boolean;
+        error: {
+            name: string;
+            message: string;
+        };
+        fake: import("../../../api/round/close").TApiRoundCloseFake;
+    };
+    roundsHistory: {
+        isPending: boolean;
+        error: import("../../../../entities/roundsHistory/model/roundsHistorySlice").TRoundsHistoryError;
+        rounds: import("../../../api/roundsHistory").THistoryRoundData[];
+        selectedRoundUUID: string;
+        replayRound: {
+            date: string;
+            replayUrl: string;
+            bet: number;
+            win: number;
+        };
+        replayStatus: "start" | "end";
+        fake: import("../../../api/roundsHistory").TApiRoundsHistoryFake;
+    };
+    gameInfo: {
+        deferredConfig: import("../../../../truelogic").TGameInfoConfig;
+        containers: import("../../../ui/InfoConstructor").TInfoContainer[];
+        background?: string | {
+            portrait?: string;
+            landscape?: string;
+        };
+        preset?: import("../../../../entities/gameInfo").TGameInfoPreset;
+    };
+    apiRoundPlay: {
+        data: import("../../../api/round/play").TApiRoundPlayResponse;
+        isPending: boolean;
+        error: {
+            name: string;
+            message: string;
+        };
+        fake: import("../../../api/round/play").TApiRoundPlayFake;
+    };
+    freeRounds: {
+        isActive: boolean;
+        displayCount: number;
+        displayTotalWon: number;
+        current: import("../../../api/round/open").TPromoTool;
+        initial: import("../../../api/round/open").TPromoTool;
+        version: `${import("../../types/theme").EVersion}`;
+    };
+    apiRoundReplay: import("../../../../app/config/types/apiRoundReplay").TApiRoundReplayState;
+    gameSettings: import("../../../api/config").TGameSettings;
+    complianceSettings: import("../../../api/config").TComplianceSettings;
+    fullScreen: {
+        isFullScreenSupported: boolean;
+        isFullScreenEnabled: boolean;
+    };
+    topLine: {
+        config: import("../../../model/topLine").TTopLineConfig;
+    };
+    fillFrame: {
+        config: {
+            enabled: boolean;
+            portrait?: {
+                width: number;
+                height: number;
+            };
+            landscape?: {
+                width: number;
+                height: number;
+            };
+        };
+    };
+    prizeDrop: {
+        campaign?: import("../../../model/prizeDrop").TPrizeDropCampaign;
+        winDropItem?: import("../../../model/prizeDrop").TPrizeDropWinItem;
+        apiCampaignsList: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListFake;
+        };
+        apiJoinCampaign: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignFake;
+        };
+        apiSocketCredentials: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsFake;
+        };
+        socketConnection?: {
+            data: null;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../sockets").TSocketPrizeDropFake;
+        } & {
+            isSuccess: boolean;
+        };
+        restData?: import("../../../api/prizeDrop").TPrizeDropApiData;
+        hasDefferedModal?: boolean;
+        defferedCampaign?: import("../../../sockets").TPrizeDropSocketEventPayloadCampaignUpdated;
+    };
+} & import("redux-persist/es/persistReducer").PersistPartial, import("redux").Action, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        viewPort: import("../../../viewPort/lib/types").TViewPortState;
+        loading: {
+            config: import("../../../model/loading").TLoadingConfig;
+            gameLoadingProgress: number;
+            imagesLoadingProgress: number;
+            areFontsLoaded: boolean;
+            areTranslationsLoaded: boolean;
+            isFinishedAnimation: boolean;
+            isPreloadNonCriticalSuccess: boolean;
+            isPreloadPanelSuccess: boolean;
+            isWaitingSuccess: boolean;
+            isImagesLoadingFinished: boolean;
+            isGameLoadingStarted: boolean;
+            isLoadingAssetsPreloaded: boolean;
+            nonCriticalImagesToLoad: number;
+            nonCriticalImagesLoaded: number;
+            panelImagesToLoad: number;
+            panelImagesLoaded: number;
+        };
+        welcome: {
+            config: import("../../../model/welcome").TWelcomeConfig;
+        };
+        apiConfig: import("../../../../app/config/types/apiConfig").TApiConfigState;
+        stake: import("../../../../entities/stake/model/stakeSlice").TStakeState;
+        autoPlay: {
+            isActive: boolean;
+            isAvailable?: boolean;
+            lossLimitTotal: number;
+            inProgress: boolean;
+            isVisibleDropdown: 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;
+            partner: string;
+            balance: number;
+            balancePrevious: number;
+            netValue: number;
+            netValuePrevious: number;
+            shouldResetNetValue: boolean;
+            currency: string;
+            currencyDecimals: number;
+            urls: import("../../../api/config/types").TSessionUrls;
+        };
+        modals: {
+            hasOpened: boolean;
+            current: import("../../../model/modals").TModalName[];
+            configs: {
+                menu: import("../../../model/menu").TMenuConfig;
+            };
+            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: import("../../../model/app").TAppError;
+            isTestAvailable: boolean;
+            test: string;
+            isUIFrozen: boolean;
+            isIframe: boolean;
+            isBonusActive: boolean;
+            tapAnywhere: {
+                enabled: boolean;
+                type: import("../../../model/app/appSlice").TTapAnywhereType;
+                autocloseDelay: number;
+            };
+            startSessionTime?: 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;
+        };
+        apiRoundOpen: {
+            data: import("../../../api/round/open").TApiRoundOpenResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/round/open").TApiRoundOpenFake;
+        };
+        fastPlay: {
+            isActive: boolean;
+        };
+        bonus: {
+            modes: import("../../../model/bonus").TBonusModes;
+            hasBonusGame: boolean;
+            currentModeNames: string[];
+            selectedModeName: string;
+            preselectedModeName: string;
+            isConfirmModalShown: boolean;
+            tmpLevel: number;
+            tmpAmountIndex: number;
+            activeSlideWidth: number;
+            activeSlideOffsetX: number;
+            isSliderInTransition: boolean;
+            isSliderInSwiping: boolean;
+            isOutsideViewportCardSelected: boolean;
+            isLastSlideOutOfView: boolean;
+        };
+        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;
+            turboRoundsDelay: number;
+            turboSkipDelay: number;
+            isTooltipActive: boolean;
+            shouldOpenTooltip: boolean;
+            tooltipCheckpoint: number;
+            isSkipCounterEnabled: boolean;
+            skipCounter: number;
+        };
+        round: {
+            roundId: string;
+            meta?: unknown;
+            responsesGS: import("../../../../truelogic").TResponseGS[];
+            isRestore: boolean;
+            wasRestore: boolean;
+            hasMaxWin: boolean;
+            current: {
+                responseGS: import("../../../../truelogic").TResponseGS;
+                responseGSIndex: number;
+                isFinished: boolean;
+                win: import("../../../../entities/round").TWin;
+                choice?: number;
+            };
+            final: {
+                balance: number;
+                winCash: number;
+            };
+        };
+        panel: {
+            config: import("../../../model/panels").TPanelConfig;
+            counterData: import("../../../model/panels").TPanelCounterData;
+        };
+        localization: import("../../../localization").TLocalizationSettings;
+        payTable: {
+            containers: import("../../../../entities/payTable").TPayTableContainer[];
+            symbolsGridV1Gap: import("../../../../entities/payTable").TSymbolsGridV1Gap;
+            background?: string | {
+                portrait?: string;
+                landscape?: string;
+            };
+        };
+        apiRoundClose: {
+            data: import("../../../api/round/close").TApiRoundCloseResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/round/close").TApiRoundCloseFake;
+        };
+        roundsHistory: {
+            isPending: boolean;
+            error: import("../../../../entities/roundsHistory/model/roundsHistorySlice").TRoundsHistoryError;
+            rounds: import("../../../api/roundsHistory").THistoryRoundData[];
+            selectedRoundUUID: string;
+            replayRound: {
+                date: string;
+                replayUrl: string;
+                bet: number;
+                win: number;
+            };
+            replayStatus: "start" | "end";
+            fake: import("../../../api/roundsHistory").TApiRoundsHistoryFake;
+        };
+        gameInfo: {
+            deferredConfig: import("../../../../truelogic").TGameInfoConfig;
+            containers: import("../../../ui/InfoConstructor").TInfoContainer[];
+            background?: string | {
+                portrait?: string;
+                landscape?: string;
+            };
+            preset?: import("../../../../entities/gameInfo").TGameInfoPreset;
+        };
+        apiRoundPlay: {
+            data: import("../../../api/round/play").TApiRoundPlayResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/round/play").TApiRoundPlayFake;
+        };
+        freeRounds: {
+            isActive: boolean;
+            displayCount: number;
+            displayTotalWon: number;
+            current: import("../../../api/round/open").TPromoTool;
+            initial: import("../../../api/round/open").TPromoTool;
+            version: `${import("../../types/theme").EVersion}`;
+        };
+        apiRoundReplay: import("../../../../app/config/types/apiRoundReplay").TApiRoundReplayState;
+        gameSettings: import("../../../api/config").TGameSettings;
+        complianceSettings: import("../../../api/config").TComplianceSettings;
+        fullScreen: {
+            isFullScreenSupported: boolean;
+            isFullScreenEnabled: boolean;
+        };
+        topLine: {
+            config: import("../../../model/topLine").TTopLineConfig;
+        };
+        fillFrame: {
+            config: {
+                enabled: boolean;
+                portrait?: {
+                    width: number;
+                    height: number;
+                };
+                landscape?: {
+                    width: number;
+                    height: number;
+                };
+            };
+        };
+        prizeDrop: {
+            campaign?: import("../../../model/prizeDrop").TPrizeDropCampaign;
+            winDropItem?: import("../../../model/prizeDrop").TPrizeDropWinItem;
+            apiCampaignsList: {
+                data: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListResponse;
+                isPending: boolean;
+                error: {
+                    name: string;
+                    message: string;
+                };
+                fake: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListFake;
+            };
+            apiJoinCampaign: {
+                data: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignResponse;
+                isPending: boolean;
+                error: {
+                    name: string;
+                    message: string;
+                };
+                fake: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignFake;
+            };
+            apiSocketCredentials: {
+                data: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsResponse;
+                isPending: boolean;
+                error: {
+                    name: string;
+                    message: string;
+                };
+                fake: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsFake;
+            };
+            socketConnection?: {
+                data: null;
+                isPending: boolean;
+                error: {
+                    name: string;
+                    message: string;
+                };
+                fake: import("../../../sockets").TSocketPrizeDropFake;
+            } & {
+                isSuccess: boolean;
+            };
+            restData?: import("../../../api/prizeDrop").TPrizeDropApiData;
+            hasDefferedModal?: boolean;
+            defferedCampaign?: import("../../../sockets").TPrizeDropSocketEventPayloadCampaignUpdated;
+        };
+    } & import("redux-persist/es/persistReducer").PersistPartial, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;

package/dist/types/src/shared/lib/types/complianceOptions.d.ts

@@ -0,0 +1,16 @@
+/** @deprecated */
+export type TComplianceOptions = {
+    /** @deprecated */
+    compliance?: {
+        /** @deprecated */
+        isHidden?: boolean;
+        /** @deprecated */
+        isBuyBonusInfo?: boolean;
+        /** @deprecated */
+        isDesktopInfo?: boolean;
+        /** @deprecated */
+        isAutoPlayInfo?: boolean;
+        /** @deprecated */
+        isFastPlayInfo?: boolean;
+    };
+};