@truelab/truelogic 3.2.3 → 3.3.0

package/dist/types/config/webpack/types.d.ts

@@ -4,7 +4,9 @@ export type TBuildPaths = {
     entrySandbox: string;
     entryGUI: string;
     output: string;
+    ouputLocales: string;
     src: string;
+    srcLocales: string;
     public: string;
     templateSandbox: string;
     templatePreloader: string;

package/dist/types/docs/src/components/StorybookPreview.d.ts

@@ -1,9 +1,11 @@
 type TProps = {
-    resourceUrl?: string;
     id: string;
+    /** For stories without changing dimensions after loading */
+    forceDimensions: boolean;
+    resourceUrl?: string;
     width?: string;
     height?: string;
     title?: string;
 };
-declare const StorybookPreview: ({ resourceUrl, id, width, height, title, }: TProps) => import("react/jsx-runtime").JSX.Element;
+declare const StorybookPreview: ({ forceDimensions, resourceUrl, id, width: defaultWidth, height: defaultHeight, title, }: TProps) => import("react/jsx-runtime").JSX.Element;
 export default StorybookPreview;

package/dist/types/docs/src/theme/MDXComponents.d.ts

@@ -1,10 +1,2 @@
-declare const _default: {
-    StorybookPreview: ({ resourceUrl, id, width, height, title, }: {
-        resourceUrl?: string;
-        id: string;
-        width?: string;
-        height?: string;
-        title?: string;
-    }) => import("react/jsx-runtime").JSX.Element;
-};
+declare const _default: any;
 export default _default;

package/dist/types/src/app/lib/integration/index.d.ts

@@ -1 +1,2 @@
 export { usePublicEvents } from './publicEvents/usePublicEvents';
+export { useSocketEvents } from './socketEvents/useSocketEvents';

package/dist/types/src/app/lib/integration/socketEvents/useSocketEvents.d.ts

@@ -0,0 +1 @@
+export declare function useSocketEvents(): void;

package/dist/types/src/app/lib/singletones/publicEmitter.d.ts

@@ -7,6 +7,7 @@ import { TWin } from "../../../entities/round";
 import { TSoundsConfig } from "../../../entities/sound";
 import { TMeetUiConfig } from "../../../features/meetUi";
 import { TApiConfigFake } from "../../../shared/api/config";
+import { TApiPrizeDropCampaignsListFake, TApiPrizeDropJoinCampaignFake, TApiPrizeDropSocketCredentialsFake } from "../../../shared/api/prizeDrop";
 import { TApiRoundCloseFake } from "../../../shared/api/round/close";
 import { TApiRoundOpenFake } from "../../../shared/api/round/open";
 import { TApiRoundPlayFake } from "../../../shared/api/round/play";
@@ -33,6 +34,9 @@ export type TInitConfig = {
         roundClose?: TApiRoundCloseFake;
         roundsHistory?: TApiRoundsHistoryFake;
         roundReplay?: TApiRoundReplayFake;
+        prizeDropCampaignsList?: TApiPrizeDropCampaignsListFake;
+        prizeDropJoinCampaign?: TApiPrizeDropJoinCampaignFake;
+        prizeDropSocketCredentials?: TApiPrizeDropSocketCredentialsFake;
     };
     analytics?: {
         google?: TGoogleAnlyticsConfig;
@@ -56,7 +60,6 @@ export type TConfiguration = {
     gameInfo?: TGameInfoConfig;
     freeRounds?: TFreeRoundsConfig;
     sounds?: TSoundsConfig;
-    logger?: TLoggerConfig;
     fillFrame?: TFillFrameConfig;
     meetUi?: TMeetUiConfig;
 };

package/dist/types/src/app/store.d.ts

@@ -6,6 +6,7 @@ export declare const rootReducer: import("redux").Reducer<{
         gameLoadingProgress: number;
         imagesLoadingProgress: number;
         areFontsLoaded: boolean;
+        areTranslationsLoaded: boolean;
         isFinishedAnimation: boolean;
         isPreloadSuccess: boolean;
         isWaitingSuccess: boolean;
@@ -79,7 +80,7 @@ export declare const rootReducer: import("redux").Reducer<{
         isModalReady: boolean;
         serviceErrorName: string;
         serviceErrorMessage: string;
-        serviceAutoplayType: import("../shared/model/modals/modalsSlice").TAutoplayServiceModalType;
+        serviceAutoplayType: import("../entities/autoplay").TAutoplayServiceModalType;
     };
     app: {
         screen: import("../shared/model/app/appSlice").TScreen;
@@ -255,13 +256,13 @@ export declare const rootReducer: import("redux").Reducer<{
         fake: import("../shared/api/roundsHistory").TApiRoundsHistoryFake;
     };
     gameInfo: {
-        containers: import("../entities/gameInfo").TGameInfoContainer[];
+        deferredConfig: import("../entities/gameInfo").TGameInfoConfig;
+        containers: import("../shared/ui/InfoConstructor").TInfoContainer[];
         background?: {
             portrait?: string;
             landscape?: string;
         };
-        version?: string;
-        lastUpdate?: string;
+        preset?: import("../entities/gameInfo").TGameInfoPreset;
     };
     apiRoundPlay: {
         data: import("../shared/api/round/play").TApiRoundPlayResponse;
@@ -314,10 +315,39 @@ export declare const rootReducer: import("redux").Reducer<{
         showed?: boolean;
     };
     prizeDrop: {
-        config?: {
-            isActive: boolean;
-            version: "default" | "dynamic";
+        rulesContainers: import("../shared/ui/InfoConstructor").TInfoContainer[];
+        campaign?: import("../shared/model/prizeDrop").TPrizeDropCampaign;
+        winDropItem?: import("../shared/model/prizeDrop").TPrizeDropWinItem;
+        apiCampaignsList: {
+            data: import("../shared/api/prizeDrop").TApiPrizeDropCampaignsListResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../shared/api/prizeDrop").TApiPrizeDropCampaignsListFake;
+        };
+        apiJoinCampaign: {
+            data: import("../shared/api/prizeDrop").TApiPrizeDropJoinCampaignResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../shared/api/prizeDrop").TApiPrizeDropJoinCampaignFake;
+        };
+        apiSocketCredentials: {
+            data: import("../shared/api/prizeDrop").TApiPrizeDropSocketCredentialsResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../shared/api/prizeDrop").TApiPrizeDropSocketCredentialsFake;
         };
+        socketConnection?: import("../shared/sockets").TPrizeDropSocketConnection;
+        restData?: import("../shared/api/prizeDrop").TPrizeDropApiData;
+        hasDefferedModal?: boolean;
     };
 }, import("redux").UnknownAction, Partial<{
     viewPort: import("../shared/viewPort/lib/types").TViewPortState;
@@ -327,6 +357,7 @@ export declare const rootReducer: import("redux").Reducer<{
         gameLoadingProgress: number;
         imagesLoadingProgress: number;
         areFontsLoaded: boolean;
+        areTranslationsLoaded: boolean;
         isFinishedAnimation: boolean;
         isPreloadSuccess: boolean;
         isWaitingSuccess: boolean;
@@ -400,7 +431,7 @@ export declare const rootReducer: import("redux").Reducer<{
         isModalReady: boolean;
         serviceErrorName: string;
         serviceErrorMessage: string;
-        serviceAutoplayType: import("../shared/model/modals/modalsSlice").TAutoplayServiceModalType;
+        serviceAutoplayType: import("../entities/autoplay").TAutoplayServiceModalType;
     };
     app: {
         screen: import("../shared/model/app/appSlice").TScreen;
@@ -576,13 +607,13 @@ export declare const rootReducer: import("redux").Reducer<{
         fake: import("../shared/api/roundsHistory").TApiRoundsHistoryFake;
     };
     gameInfo: {
-        containers: import("../entities/gameInfo").TGameInfoContainer[];
+        deferredConfig: import("../entities/gameInfo").TGameInfoConfig;
+        containers: import("../shared/ui/InfoConstructor").TInfoContainer[];
         background?: {
             portrait?: string;
             landscape?: string;
         };
-        version?: string;
-        lastUpdate?: string;
+        preset?: import("../entities/gameInfo").TGameInfoPreset;
     };
     apiRoundPlay: {
         data: import("../shared/api/round/play").TApiRoundPlayResponse;
@@ -635,10 +666,39 @@ export declare const rootReducer: import("redux").Reducer<{
         showed?: boolean;
     };
     prizeDrop: {
-        config?: {
-            isActive: boolean;
-            version: "default" | "dynamic";
+        rulesContainers: import("../shared/ui/InfoConstructor").TInfoContainer[];
+        campaign?: import("../shared/model/prizeDrop").TPrizeDropCampaign;
+        winDropItem?: import("../shared/model/prizeDrop").TPrizeDropWinItem;
+        apiCampaignsList: {
+            data: import("../shared/api/prizeDrop").TApiPrizeDropCampaignsListResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../shared/api/prizeDrop").TApiPrizeDropCampaignsListFake;
+        };
+        apiJoinCampaign: {
+            data: import("../shared/api/prizeDrop").TApiPrizeDropJoinCampaignResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../shared/api/prizeDrop").TApiPrizeDropJoinCampaignFake;
         };
+        apiSocketCredentials: {
+            data: import("../shared/api/prizeDrop").TApiPrizeDropSocketCredentialsResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../shared/api/prizeDrop").TApiPrizeDropSocketCredentialsFake;
+        };
+        socketConnection?: import("../shared/sockets").TPrizeDropSocketConnection;
+        restData?: import("../shared/api/prizeDrop").TPrizeDropApiData;
+        hasDefferedModal?: boolean;
     };
 }>>;
 export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
@@ -649,6 +709,7 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
         gameLoadingProgress: number;
         imagesLoadingProgress: number;
         areFontsLoaded: boolean;
+        areTranslationsLoaded: boolean;
         isFinishedAnimation: boolean;
         isPreloadSuccess: boolean;
         isWaitingSuccess: boolean;
@@ -722,7 +783,7 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
         isModalReady: boolean;
         serviceErrorName: string;
         serviceErrorMessage: string;
-        serviceAutoplayType: import("../shared/model/modals/modalsSlice").TAutoplayServiceModalType;
+        serviceAutoplayType: import("../entities/autoplay").TAutoplayServiceModalType;
     };
     app: {
         screen: import("../shared/model/app/appSlice").TScreen;
@@ -898,13 +959,13 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
         fake: import("../shared/api/roundsHistory").TApiRoundsHistoryFake;
     };
     gameInfo: {
-        containers: import("../entities/gameInfo").TGameInfoContainer[];
+        deferredConfig: import("../entities/gameInfo").TGameInfoConfig;
+        containers: import("../shared/ui/InfoConstructor").TInfoContainer[];
         background?: {
             portrait?: string;
             landscape?: string;
         };
-        version?: string;
-        lastUpdate?: string;
+        preset?: import("../entities/gameInfo").TGameInfoPreset;
     };
     apiRoundPlay: {
         data: import("../shared/api/round/play").TApiRoundPlayResponse;
@@ -957,10 +1018,39 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
         showed?: boolean;
     };
     prizeDrop: {
-        config?: {
-            isActive: boolean;
-            version: "default" | "dynamic";
+        rulesContainers: import("../shared/ui/InfoConstructor").TInfoContainer[];
+        campaign?: import("../shared/model/prizeDrop").TPrizeDropCampaign;
+        winDropItem?: import("../shared/model/prizeDrop").TPrizeDropWinItem;
+        apiCampaignsList: {
+            data: import("../shared/api/prizeDrop").TApiPrizeDropCampaignsListResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../shared/api/prizeDrop").TApiPrizeDropCampaignsListFake;
         };
+        apiJoinCampaign: {
+            data: import("../shared/api/prizeDrop").TApiPrizeDropJoinCampaignResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../shared/api/prizeDrop").TApiPrizeDropJoinCampaignFake;
+        };
+        apiSocketCredentials: {
+            data: import("../shared/api/prizeDrop").TApiPrizeDropSocketCredentialsResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../shared/api/prizeDrop").TApiPrizeDropSocketCredentialsFake;
+        };
+        socketConnection?: import("../shared/sockets").TPrizeDropSocketConnection;
+        restData?: import("../shared/api/prizeDrop").TPrizeDropApiData;
+        hasDefferedModal?: boolean;
     };
 } & import("redux-persist/es/persistReducer").PersistPartial, import("redux").Action, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
     dispatch: import("redux-thunk").ThunkDispatch<{
@@ -971,6 +1061,7 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
             gameLoadingProgress: number;
             imagesLoadingProgress: number;
             areFontsLoaded: boolean;
+            areTranslationsLoaded: boolean;
             isFinishedAnimation: boolean;
             isPreloadSuccess: boolean;
             isWaitingSuccess: boolean;
@@ -1044,7 +1135,7 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
             isModalReady: boolean;
             serviceErrorName: string;
             serviceErrorMessage: string;
-            serviceAutoplayType: import("../shared/model/modals/modalsSlice").TAutoplayServiceModalType;
+            serviceAutoplayType: import("../entities/autoplay").TAutoplayServiceModalType;
         };
         app: {
             screen: import("../shared/model/app/appSlice").TScreen;
@@ -1220,13 +1311,13 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
             fake: import("../shared/api/roundsHistory").TApiRoundsHistoryFake;
         };
         gameInfo: {
-            containers: import("../entities/gameInfo").TGameInfoContainer[];
+            deferredConfig: import("../entities/gameInfo").TGameInfoConfig;
+            containers: import("../shared/ui/InfoConstructor").TInfoContainer[];
             background?: {
                 portrait?: string;
                 landscape?: string;
             };
-            version?: string;
-            lastUpdate?: string;
+            preset?: import("../entities/gameInfo").TGameInfoPreset;
         };
         apiRoundPlay: {
             data: import("../shared/api/round/play").TApiRoundPlayResponse;
@@ -1279,10 +1370,39 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
             showed?: boolean;
         };
         prizeDrop: {
-            config?: {
-                isActive: boolean;
-                version: "default" | "dynamic";
+            rulesContainers: import("../shared/ui/InfoConstructor").TInfoContainer[];
+            campaign?: import("../shared/model/prizeDrop").TPrizeDropCampaign;
+            winDropItem?: import("../shared/model/prizeDrop").TPrizeDropWinItem;
+            apiCampaignsList: {
+                data: import("../shared/api/prizeDrop").TApiPrizeDropCampaignsListResponse;
+                isPending: boolean;
+                error: {
+                    name: string;
+                    message: string;
+                };
+                fake: import("../shared/api/prizeDrop").TApiPrizeDropCampaignsListFake;
+            };
+            apiJoinCampaign: {
+                data: import("../shared/api/prizeDrop").TApiPrizeDropJoinCampaignResponse;
+                isPending: boolean;
+                error: {
+                    name: string;
+                    message: string;
+                };
+                fake: import("../shared/api/prizeDrop").TApiPrizeDropJoinCampaignFake;
+            };
+            apiSocketCredentials: {
+                data: import("../shared/api/prizeDrop").TApiPrizeDropSocketCredentialsResponse;
+                isPending: boolean;
+                error: {
+                    name: string;
+                    message: string;
+                };
+                fake: import("../shared/api/prizeDrop").TApiPrizeDropSocketCredentialsFake;
             };
+            socketConnection?: import("../shared/sockets").TPrizeDropSocketConnection;
+            restData?: import("../shared/api/prizeDrop").TPrizeDropApiData;
+            hasDefferedModal?: boolean;
         };
     } & import("redux-persist/es/persistReducer").PersistPartial, undefined, import("redux").UnknownAction>;
 }>, import("redux").StoreEnhancer]>>;

package/dist/types/src/entities/autoplay/index.d.ts

@@ -1,2 +1,3 @@
+export { TAutoplayServiceModalType } from './lib/types';
 export { useAutoplayNumbers } from './lib/useAutoplayNumbers';
 export { autoPlayReducer, calcAutoPlayLossLimit, decreaseAutoPlayNumber, getAutoPlayIsReadyForStart, setAutoPlayActiveIndex, setAutoPlayActiveNumber, setAutoPlayConfig, setAutoPlayEnd, setAutoPlayLossLimit, setAutoPlayProgress, setAutoPlaySingleWin, setAutoPlayStart, setAutoPlayStopInBonusGame, setAutoPlayVisibleDropdown, } from './model/autoPlaySlice';

package/dist/types/src/entities/autoplay/lib/types.d.ts

@@ -0,0 +1 @@
+export type TAutoplayServiceModalType = 'numSpins' | 'lossLimit' | 'singleWinLimit' | 'bonusReached';

package/dist/types/src/entities/complianceSettings/lib/isDisabledByCompliance.d.ts

@@ -1,3 +1,4 @@
 import { TComplianceSettings } from "../../../shared/api/config";
 import { TComplianceOptions } from "../../../shared/lib/types/complianceOptions";
+/** @deprecated */
 export declare const isDisabledByCompliance: (complianceOptions: TComplianceOptions, complianceSettings: TComplianceSettings, isDesktop: boolean) => boolean;

package/dist/types/src/entities/gameInfo/index.d.ts

@@ -1,11 +1,2 @@
-export { gameInfoReducer, setGameInfoConfig } from './model/gameInfoSlice';
-export { TGameInfoConfig, TGameInfoContainer, TGameInfoItem, TGameInfoSeparator } from './model/types';
-export { GameInfoConstructor } from './ui/GameInfoConstructor/GameInfoConstructor';
-export { EFeatureAlignmentV1Type, GameInfoFeatureV1, TGameInfoFeatureV1, } from './ui/GameInfoConstructor/items/GameInfoFeatureV1';
-export { EFeatureWidthV2Type, GameInfoFeatureV2, TGameInfoFeatureV2, } from './ui/GameInfoConstructor/items/GameInfoFeatureV2';
-export { GameInfoListItem, TGameInfoListItem } from './ui/GameInfoConstructor/items/GameInfoListItem';
-export { GameInfoSubTitle, TGameInfoSubTitle } from './ui/GameInfoConstructor/items/GameInfoSubTitle';
-export { GameInfoTableCell, TGameInfoTableCell } from './ui/GameInfoConstructor/items/GameInfoTableCell';
-export { GameInfoTableHead, TGameInfoTableHead } from './ui/GameInfoConstructor/items/GameInfoTableHead';
-export { GameInfoText, TGameInfoText } from './ui/GameInfoConstructor/items/GameInfoText';
-export { GameInfoTitle, TGameInfoTitle } from './ui/GameInfoConstructor/items/GameInfoTitle';
+export { gameInfoReducer, saveGameInfoConfig, setGameInfoConfig } from './model/gameInfoSlice';
+export { TGameInfoConfig, TGameInfoPreset } from './model/types';

package/dist/types/src/entities/gameInfo/model/gameInfoSlice.d.ts

@@ -1,21 +1,16 @@
-import { TGameInfoContainer, TGameInfoItem } from './types';
+import { TAppThunkAction } from "../../../shared/lib/store";
+import { TInfoContainer } from "../../../shared/ui/InfoConstructor";
+import { TGameInfoConfig, TGameInfoPreset } from './types';
 type TGameInfoState = {
-    containers: TGameInfoContainer[];
+    deferredConfig: TGameInfoConfig;
+    containers: TInfoContainer[];
     background?: {
         portrait?: string;
         landscape?: string;
     };
-    version?: string;
-    lastUpdate?: string;
+    preset?: TGameInfoPreset;
 };
-export declare const setGameInfoConfig: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
-    items: TGameInfoItem[];
-    version: string;
-    lastUpdate: string;
-    background?: {
-        portrait?: string;
-        landscape?: string;
-    };
-}, "gameInfo/setGameInfoConfig">;
+export declare const handleGameInfoConfig: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TGameInfoConfig, "gameInfo/handleGameInfoConfig">, saveGameInfoConfig: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TGameInfoConfig, "gameInfo/saveGameInfoConfig">;
 export declare const gameInfoReducer: import("redux").Reducer<TGameInfoState>;
+export declare const setGameInfoConfig: TAppThunkAction;
 export {};

package/dist/types/src/entities/gameInfo/model/presets/getTruelabGamePreset.d.ts

@@ -0,0 +1,3 @@
+import type { TInfoItem } from "../../../../shared/ui/InfoConstructor";
+import { TGameInfoPreset } from '../types';
+export declare function getTruelabGamePreset(state: TRootState, preset: TGameInfoPreset): TInfoItem[];

package/dist/types/src/entities/gameInfo/model/types.d.ts

@@ -1,49 +1,16 @@
-import { TComplianceOptions } from "../../../shared/lib/types/complianceOptions";
 import { TAdaptiveImage } from "../../../shared/lib/types/image";
-import { TGameInfoFeatureV1 } from '../ui/GameInfoConstructor/items/GameInfoFeatureV1';
-import { TGameInfoFeatureV2 } from '../ui/GameInfoConstructor/items/GameInfoFeatureV2';
-import { TGameInfoListItem } from '../ui/GameInfoConstructor/items/GameInfoListItem';
-import { TGameInfoSubTitle } from '../ui/GameInfoConstructor/items/GameInfoSubTitle';
-import { TGameInfoTableCell } from '../ui/GameInfoConstructor/items/GameInfoTableCell';
-import { TGameInfoTableHead } from '../ui/GameInfoConstructor/items/GameInfoTableHead';
-import { TGameInfoText } from '../ui/GameInfoConstructor/items/GameInfoText';
-import { TGameInfoTitle } from '../ui/GameInfoConstructor/items/GameInfoTitle';
-export type TGameInfoSeparator = {
-    type: 'separator';
-    size?: 'default' | 'small';
-} & TComplianceOptions;
-export type TGameInfoItem = TGameInfoTitle | TGameInfoFeatureV1 | TGameInfoFeatureV2 | TGameInfoSeparator | TGameInfoSubTitle | TGameInfoText | TGameInfoListItem | TGameInfoTableHead | TGameInfoTableCell;
-export type TGameInfoContainer = {
-    type: TGameInfoTitle['type'];
-    items: TGameInfoTitle[];
-} | {
-    type: TGameInfoFeatureV1['type'];
-    items: TGameInfoFeatureV1[];
-} | {
-    type: TGameInfoFeatureV2['type'];
-    items: TGameInfoFeatureV2[];
-} | {
-    type: TGameInfoSeparator['type'];
-    items: TGameInfoSeparator[];
-} | {
-    type: TGameInfoSubTitle['type'];
-    items: TGameInfoSubTitle[];
-} | {
-    type: TGameInfoText['type'];
-    items: TGameInfoText[];
-} | {
-    type: TGameInfoListItem['type'];
-    items: TGameInfoListItem[];
-} | {
-    type: TGameInfoTableHead['type'];
-    items: TGameInfoTableHead[];
-} | {
-    type: TGameInfoTableCell['type'];
-    items: TGameInfoTableCell[];
-};
-export type TGameInfoConfig = {
-    items: TGameInfoItem[];
+import { TInfoItem } from "../../../shared/ui/InfoConstructor";
+export type TGameInfoPreset = {
+    name: 'truelab-game';
     version: string;
     lastUpdate: string;
+};
+export type TGameInfoConfig = {
+    items: TInfoItem[];
+    /** @deprecated */
+    version?: string;
+    /** @deprecated */
+    lastUpdate?: string;
     background?: TAdaptiveImage;
+    preset?: TGameInfoPreset;
 };

package/dist/types/src/entities/loading/index.d.ts

@@ -1,4 +1,4 @@
 export { useLoadingListeners } from './lib/useLoadingListeners';
-export { getLoadingIsSuccess, getLoadingProgress, loadingReducer, preloadFonts, preloadImages, preloadLoadingImages, setLoadingAssetsPreloaded, setLoadingConfig, setLoadingFinishedAnimation, setLoadingFontsLoaded, setLoadingGameProgress, setLoadingGameStarted, setLoadingWaitingSuccess, } from './model/loadingSlice';
+export { getLoadingIsSuccess, getLoadingProgress, loadingReducer, preloadFonts, preloadImages, preloadLoadingImages, preloadTranslations, setLoadingAssetsPreloaded, setLoadingConfig, setLoadingFinishedAnimation, setLoadingFontsLoaded, setLoadingGameProgress, setLoadingGameStarted, setLoadingWaitingSuccess, } from './model/loadingSlice';
 export { GameLoader } from './ui/default/GameLoader';
 export { GameLoaderPro } from './ui/pro/GameLoaderPro';

package/dist/types/src/entities/loading/model/loadingSlice.d.ts

@@ -6,6 +6,7 @@ type TLoadingState = {
     gameLoadingProgress: number;
     imagesLoadingProgress: number;
     areFontsLoaded: boolean;
+    areTranslationsLoaded: boolean;
     isFinishedAnimation: boolean;
     isPreloadSuccess: boolean;
     isWaitingSuccess: boolean;
@@ -15,7 +16,7 @@ type TLoadingState = {
     imagesToLoad: number;
     imagesLoaded: number;
 };
-export declare const setLoadingGameProgress: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "loading/setLoadingGameProgress">, setLoadingFinishedAnimation: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "loading/setLoadingFinishedAnimation">, setLoadingWaitingSuccess: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "loading/setLoadingWaitingSuccess">, setLoadingConfig: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TLoadingConfig, "loading/setLoadingConfig">, setLoadingImagesToLoad: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "loading/setLoadingImagesToLoad">, setLoadingImagesLoaded: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "loading/setLoadingImagesLoaded">, setLoadingGameStarted: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loading/setLoadingGameStarted">, setLoadingPreloadingSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loading/setLoadingPreloadingSuccess">, setLoadingAssetsPreloaded: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loading/setLoadingAssetsPreloaded">, setLoadingFontsLoaded: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loading/setLoadingFontsLoaded">;
+export declare const setLoadingGameProgress: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "loading/setLoadingGameProgress">, setLoadingFinishedAnimation: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "loading/setLoadingFinishedAnimation">, setLoadingWaitingSuccess: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "loading/setLoadingWaitingSuccess">, setLoadingConfig: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TLoadingConfig, "loading/setLoadingConfig">, setLoadingImagesToLoad: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "loading/setLoadingImagesToLoad">, setLoadingImagesLoaded: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "loading/setLoadingImagesLoaded">, setLoadingGameStarted: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loading/setLoadingGameStarted">, setLoadingPreloadingSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loading/setLoadingPreloadingSuccess">, setLoadingAssetsPreloaded: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loading/setLoadingAssetsPreloaded">, setLoadingFontsLoaded: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loading/setLoadingFontsLoaded">, setLoadingTranslationsLoaded: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loading/setLoadingTranslationsLoaded">;
 export declare const getLoadingIsSuccess: import("reselect").Selector<{
     loading: TLoadingState;
 }, boolean, []> & {
@@ -29,4 +30,5 @@ export declare const loadingReducer: import("redux").Reducer<TLoadingState>;
 export declare const preloadImages: TAppThunkAction<string[]>;
 export declare const preloadFonts: TAppThunkAction<TFontsConfig>;
 export declare const preloadLoadingImages: TAppThunkAction<string[]>;
+export declare const preloadTranslations: TAppThunkAction<string>;
 export {};

package/dist/types/src/entities/prizeDrop/index.d.ts

@@ -1,4 +1,9 @@
-export { prizeDropReducer } from './model/prizeDropSlice';
+export { clearPrizeDropWinItem, connectPrizeDropSocketService, fetchApiPrizeDropCampaignsList, fetchApiPrizeDropJoinCampaign, fetchApiPrizeDropSocketCredentials, getPrizeDropMode, handlePrizeDropSocketEventCampaignUpdated, handlePrizeDropSocketEventDrop, isPrizeDropActive, isPrizeDropJoined, joinPrizeDropCampaign, prizeDropReducer, setApiPrizeDropCampaignsListFake, setApiPrizeDropJoinCampaignFake, setApiPrizeDropSocketCredentialsFake, setPrizeDropCampaign, setPrizeDropRestData, setPrizeDropRulesConfig, setPrizeDropSocketData, setPrizeDropWinItem, TPrizeDropMode, } from './model/prizeDropSlice';
 export { PanelPrizeDrop } from './ui/PanelPrizeDrop';
-export { PrizeDropEvent } from './ui/PrizeDropEvent';
+export { PrizeDropBadge } from './ui/PrizeDropBadge';
+export { PrizeDropButton } from './ui/PrizeDropButton';
+export { PrizeDropEvents } from './ui/PrizeDropEvents';
+export { PrizeDropInterval } from './ui/PrizeDropInterval';
+export { PrizeDropPrizePool } from './ui/PrizeDropPrizePool';
 export { PrizeDropRules } from './ui/PrizeDropRules';
+export { TabsHeader, TTabId, TTabsHeaderConfig } from './ui/TabsHeader';

package/dist/types/src/entities/prizeDrop/model/prizeDropSlice.d.ts

@@ -1,8 +1,56 @@
-type TPrizeDropsState = {
-    config?: {
-        isActive: boolean;
-        version: 'default' | 'dynamic';
+import { TApiPrizeDropCampaignsListError, TApiPrizeDropCampaignsListFake, TApiPrizeDropCampaignsListResponse, TApiPrizeDropJoinCampaignError, TApiPrizeDropJoinCampaignFake, TApiPrizeDropJoinCampaignPayload, TApiPrizeDropJoinCampaignResponse, TApiPrizeDropSocketCredentials, TApiPrizeDropSocketCredentialsError, TApiPrizeDropSocketCredentialsFake, TApiPrizeDropSocketCredentialsResponse, TPrizeDropApiData } from "../../../shared/api/prizeDrop";
+import { TAppThunkAction } from "../../../shared/lib/store";
+import { TPrizeDropCampaign, TPrizeDropWinItem } from "../../../shared/model/prizeDrop";
+import { TPrizeDropSocketConnection, TPrizeDropSocketEventPayloadCampaignUpdated, TPrizeDropSocketEventPayloadDrop } from "../../../shared/sockets";
+import { TInfoContainer, TInfoItem } from "../../../shared/ui/InfoConstructor";
+export type TPrizeDropMode = 'live' | 'upcoming' | 'ended';
+type TApiData<D, F> = {
+    data: D;
+    isPending: boolean;
+    error: {
+        name: string;
+        message: string;
     };
+    fake: F;
+};
+type TPrizeDropsState = {
+    rulesContainers: TInfoContainer[];
+    campaign?: TPrizeDropCampaign;
+    winDropItem?: TPrizeDropWinItem;
+    apiCampaignsList: TApiData<TApiPrizeDropCampaignsListResponse, TApiPrizeDropCampaignsListFake>;
+    apiJoinCampaign: TApiData<TApiPrizeDropJoinCampaignResponse, TApiPrizeDropJoinCampaignFake>;
+    apiSocketCredentials: TApiData<TApiPrizeDropSocketCredentialsResponse, TApiPrizeDropSocketCredentialsFake>;
+    socketConnection?: TPrizeDropSocketConnection;
+    restData?: TPrizeDropApiData;
+    hasDefferedModal?: boolean;
+};
+export declare const setPrizeDropRulesConfig: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    items: TInfoItem[];
+}, "prizeDrop/setPrizeDropRulesConfig">, setPrizeDropCampaign: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TPrizeDropCampaign, "prizeDrop/setPrizeDropCampaign">, setPrizeDropSocketEventCampaignUpdated: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TPrizeDropSocketEventPayloadCampaignUpdated, "prizeDrop/setPrizeDropSocketEventCampaignUpdated">, setPrizeDropSocketEventDrop: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TPrizeDropSocketEventPayloadDrop, "prizeDrop/setPrizeDropSocketEventDrop">, setPrizeDropWinItem: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TPrizeDropWinItem, "prizeDrop/setPrizeDropWinItem">, clearPrizeDropWinItem: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"prizeDrop/clearPrizeDropWinItem">, setApiPrizeDropCampaignsListFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiPrizeDropCampaignsListFake, "prizeDrop/setApiPrizeDropCampaignsListFake">, setApiPrizeDropJoinCampaignFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiPrizeDropJoinCampaignFake, "prizeDrop/setApiPrizeDropJoinCampaignFake">, setApiPrizeDropSocketCredentialsFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiPrizeDropSocketCredentialsFake, "prizeDrop/setApiPrizeDropSocketCredentialsFake">, setPrizeDropRestData: import("@reduxjs/toolkit").ActionCreatorWithNonInferrablePayload<"prizeDrop/setPrizeDropRestData">, fetchApiPrizeDropCampaignsList: import("@reduxjs/toolkit").AsyncThunk<TApiPrizeDropCampaignsListResponse, void, {
+    rejectValue: TApiPrizeDropCampaignsListError;
+}>, fetchApiPrizeDropJoinCampaign: import("@reduxjs/toolkit").AsyncThunk<TApiPrizeDropJoinCampaignResponse, TApiPrizeDropJoinCampaignPayload, {
+    rejectValue: TApiPrizeDropJoinCampaignError;
+}>, fetchApiPrizeDropSocketCredentials: import("@reduxjs/toolkit").AsyncThunk<TApiPrizeDropSocketCredentialsResponse, void, {
+    rejectValue: TApiPrizeDropSocketCredentialsError;
+}>, setPrizeDropSocketData: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiPrizeDropSocketCredentials, "prizeDrop/setPrizeDropSocketData">, connectPrizeDropSocketService: import("@reduxjs/toolkit").AsyncThunk<Promise<void>, void, {
+    rejectValue: TApiPrizeDropSocketCredentialsError;
+}>, setPrizeDropDefferedModal: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "prizeDrop/setPrizeDropDefferedModal">, joinPrizeDropCampaign: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    campaignId: string;
+}, "prizeDrop/joinPrizeDropCampaign">;
+export declare const isPrizeDropActive: import("reselect").Selector<{
+    prizeDrop: TPrizeDropsState;
+}, boolean, []> & {
+    unwrapped: (state: TPrizeDropsState) => boolean;
+}, getPrizeDropMode: import("reselect").Selector<{
+    prizeDrop: TPrizeDropsState;
+}, TPrizeDropMode, []> & {
+    unwrapped: (state: TPrizeDropsState) => TPrizeDropMode;
+}, isPrizeDropJoined: import("reselect").Selector<{
+    prizeDrop: TPrizeDropsState;
+}, boolean, []> & {
+    unwrapped: (state: TPrizeDropsState) => boolean;
 };
 export declare const prizeDropReducer: import("redux").Reducer<TPrizeDropsState>;
+export declare const handlePrizeDropSocketEventCampaignUpdated: TAppThunkAction;
+export declare const handlePrizeDropSocketEventDrop: TAppThunkAction;
 export {};

package/dist/types/src/entities/prizeDrop/ui/PrizeDropBadge.d.ts

@@ -0,0 +1,7 @@
+import { TPrizeDropMode } from '../model/prizeDropSlice';
+type TProps = {
+    prizeDropMode: TPrizeDropMode;
+    className: string;
+};
+export declare const PrizeDropBadge: ({ prizeDropMode, className }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/entities/prizeDrop/ui/PrizeDropButton.d.ts

@@ -0,0 +1,7 @@
+type TProps = {
+    onClick: (event: React.MouseEvent) => void;
+    isLoading: boolean;
+    className?: string;
+};
+export declare const PrizeDropButton: ({ onClick, isLoading, className }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/entities/prizeDrop/ui/PrizeDropEvents/PrizeDropEvents.d.ts

@@ -0,0 +1 @@
+export declare const PrizeDropEvents: () => import("react/jsx-runtime").JSX.Element;