react-memory-optimization 0.0.1

package/dist/lib/store/casino/entities/casinoTournaments/types.d.ts

@@ -0,0 +1,134 @@
+import { BaseObservableSubscriber } from 'service/observable/type';
+import { ResponseAdapter } from 'service/responseAdapter';
+import { SendCommand } from 'socket/types';
+import { AdaptedGame } from '../games/types';
+export type TournamentInfo = {
+    amount: number;
+    endDate: number;
+    id: number;
+    playerLength: number;
+    players: TournamentPlayer[];
+    startDate: number;
+    status: ECasinoTournamentStatus;
+};
+export type TournamentPlayer = {
+    id: number;
+    payout: number;
+    payoutBonus: number;
+    rolled: number;
+};
+export type AdaptedTournamentPlayer = {
+    id: number;
+    payout: string;
+    payoutBonus: string;
+    rolled: string;
+};
+export type CurrentTournamentPlayer = Omit<TournamentPlayer, 'id'> & {
+    position: number;
+};
+export type AdaptedCasinoTournamentProps = {
+    tournamentLength: number;
+    tournaments: {
+        [indx: number]: {
+            tournament: TournamentInfo;
+        };
+    };
+};
+export type AdaptedCasinoTournament = Omit<TournamentInfo, 'players' | 'playerLength'>;
+export declare enum ECasinoTournamentStatus {
+    Created = 0,
+    Active = 1,
+    Finished = 2
+}
+export type InitialTournaments = {
+    activeTournaments: TournamentInfo | null;
+    finishedTournaments: {
+        [tournamentId: number]: TournamentInfo;
+    };
+};
+export type ResponseProviderTournament = {
+    name: string;
+    id: number;
+    gameIds: number[];
+    providerName: string;
+    prizePool: {
+        [key: string]: string;
+        default: string;
+    };
+    images: {
+        [key: string]: string;
+    };
+    startDate: string;
+    endDate: string;
+    rules: {
+        [key: string]: string[];
+    };
+};
+export type ProviderTournament = Omit<ResponseProviderTournament, 'startDate' | 'endDate'> & {
+    startDate: number;
+    endDate: number;
+};
+export type RequestCommands = {
+    socket: boolean;
+    rest: boolean;
+};
+export type TournamentSettings = {
+    path: string;
+    providerBasePath: string;
+    inHouseBattlePaths: {
+        mobileActive: string;
+        desktopActive: string;
+        mobileInactive: string;
+        desktopInactive: string;
+    };
+};
+export type InHouseTournaments = {
+    finished: {
+        [tournamentId: number]: TournamentInfo;
+    };
+    active: null | TournamentInfo;
+};
+export type CasinoTournamentsProps = {
+    parent: ResponseAdapter;
+    sendCommand: SendCommand;
+    tournamentSettings: TournamentSettings;
+};
+export type BattleInfo = {
+    isInHouse: boolean;
+    id: number;
+};
+export type TournamentsSubscribe = {
+    isFinished: boolean;
+};
+export type TournamentSubscribeProps = BaseObservableSubscriber & (TournamentsSubscribe | {
+    battleInfo: BattleInfo;
+    isMobile: boolean;
+});
+export type BattleHookInfo = Omit<TournamentInfo, 'status' | 'amount' | 'players'> & {
+    isInHouse: boolean;
+    mobileImagePath: string;
+    desktopImagePath: string;
+    uid: string;
+    amount: string;
+    providerName: string;
+    isFinished: boolean;
+    players: AdaptedTournamentPlayer[];
+};
+export type BattleDetails = BattleHookInfo & {
+    isFinished: boolean;
+    providerName: string;
+    games: AdaptedGame[];
+    gameIds: number[];
+    rules: string[];
+    backgroundDesktop: string;
+    backgroundMobile: string;
+};
+export type ActiveTournaments = BattleHookInfo[];
+export type HistoryTournaments = BattleHookInfo[];
+export type GetImagesProps = {
+    desktopImagePath: string;
+    mobileImagePath: string;
+    isHistory: boolean;
+    isProvider: boolean;
+    id: number;
+};

package/dist/lib/store/casino/entities/casinoTournaments/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECasinoTournamentStatus = void 0;
+// NEW TYPES ------
+var ECasinoTournamentStatus;
+(function (ECasinoTournamentStatus) {
+    ECasinoTournamentStatus[ECasinoTournamentStatus["Created"] = 0] = "Created";
+    ECasinoTournamentStatus[ECasinoTournamentStatus["Active"] = 1] = "Active";
+    ECasinoTournamentStatus[ECasinoTournamentStatus["Finished"] = 2] = "Finished";
+})(ECasinoTournamentStatus || (exports.ECasinoTournamentStatus = ECasinoTournamentStatus = {}));

package/dist/lib/store/casino/entities/categories/index.d.ts

@@ -0,0 +1,33 @@
+import { Observable } from 'service/observable';
+import { CategoriesInfo, ObservableSettings, ResponseEncodeConfig, SubscribeCasinoCategoriesHomePageProps, SubscribeCasinoCategoriesProps, SubscribeCasinoCategoryInfoProps, SubscribeCasinoSubCategoriesProps, UpdateCategoriesProps } from './types';
+import { CasinoServices } from 'store/casino/services';
+export declare class CasinoCategories {
+    categoriesObservable: Observable;
+    observableSettings: ObservableSettings;
+    services: CasinoServices;
+    mobileCategoriesInfo: CategoriesInfo;
+    desktopCategoriesInfo: CategoriesInfo;
+    config: null | ResponseEncodeConfig;
+    isNeedToConfigureData: boolean;
+    countryId: number;
+    constructor(services: CasinoServices, urls: [string, string]);
+    private setConfig;
+    private request;
+    getMainFile(url: string): Promise<void>;
+    getConfig(urls: [string, string]): Promise<void>;
+    updateCountryId(countryId: number): void;
+    configureCasinoData(): void;
+    updateGamesRestricts(): void;
+    startCasinoConfigSubscribers(): void;
+    updateCategories({ mobile, desktop }: UpdateCategoriesProps): void;
+    private sendCategoryUpdate;
+    private sendCategoriesUpdate;
+    private sendHomeCategoriesUpdate;
+    private sendSubCategoriesUpdate;
+    sendUpdates(): void;
+    subscribeCasinoCategories(props: SubscribeCasinoCategoriesProps): void;
+    subscribeCasinoCategoriesHomePage(props: SubscribeCasinoCategoriesHomePageProps): void;
+    subscribeCasinoSubCategories(props: SubscribeCasinoSubCategoriesProps): void;
+    subscribeCasinoCategoryInfo(props: SubscribeCasinoCategoryInfoProps): void;
+    unsubscribeCasinoCategoryEntity(uid: string): void;
+}

package/dist/lib/store/casino/entities/categories/types.d.ts

@@ -0,0 +1,152 @@
+import { BinaryConvertToObjType } from 'binary/types';
+export type CasinoCategory = {
+    id: number;
+    gameIds: number[];
+    name: string;
+    sortId: number;
+};
+export type CasinoSubCategory = {
+    categoryId: number;
+    gameIds: number[];
+    name: string;
+    sortId: number;
+    subCategoryId: number;
+};
+export type CategoriesInfo = {
+    mainGroups: {
+        [categoryId: number]: CasinoCategory;
+    };
+    mainTopGames: number[];
+    popularGames: number[];
+    subGroups: {
+        [subCategoryId: number]: CasinoSubCategory[];
+    };
+};
+export type UpdateCategoriesProps = {
+    mobile: CategoriesInfo;
+    desktop: CategoriesInfo;
+};
+export declare enum ECasinoCategoryIds {
+    WagerSubCategoryTournament = -2,
+    WagerSubCategoryBonus = -1,
+    Wager = -1,
+    Crash = 1,
+    Slots = 2,
+    Casino = 3,
+    Turbo = 10,
+    Popular = 99,
+    SubSlotsNew = 101,
+    PopularSubCategory = 102,
+    SubSlotsTop = 104,
+    SubGameShow = 124
+}
+export type ObservableSettings = {
+    [uid: string]: CategoryObservable | CategoriesObservableSetting | CategoriesHomePage | SubCategoriesObservable;
+};
+export type CategoryObservable = {
+    isCategory: boolean;
+    categoryId: number;
+    isMobile: boolean;
+};
+export type SubCategoriesObservable = {
+    isSubCategories: boolean;
+    isMobile: boolean;
+    categoryId: number;
+};
+export type CategoriesObservableSetting = {
+    isCategories: boolean;
+    isMobile: boolean;
+};
+export type CategoriesHomePage = {
+    isHome: boolean;
+    isMobile: boolean;
+};
+export type SubscribeCasinoCategoriesProps = {
+    uid: string;
+    callback: (d: CasinoCategory[]) => void;
+    isMobile: boolean;
+};
+export type ResponseHomePageInfo = {
+    rows: (CasinoCategory | CasinoSubCategory)[];
+    subCategoriesInx: number[];
+};
+export type SubscribeCasinoCategoriesHomePageProps = {
+    uid: string;
+    isMobile: boolean;
+    callback: (d: ResponseHomePageInfo) => void;
+};
+export type SubscribeCasinoSubCategoriesProps = {
+    uid: string;
+    isMobile: boolean;
+    categoryId: number;
+    callback: (d: ResponseHomePageInfo) => void;
+};
+export type SubscribeCasinoCategoryInfoProps = {
+    uid: string;
+    isMobile: boolean;
+    categoryId: number;
+    callback: (d: CasinoCategory) => void;
+};
+export type ResponseCategoryName = {
+    nameKey: string;
+    name: string;
+};
+export type ResponseGameIds = {
+    gameIds: {
+        gameId: number;
+    }[];
+    convertToObj: {
+        [gameId: number]: BinaryConvertToObjType & {
+            value: number;
+        };
+    };
+};
+export declare enum ECategoryWager {
+    Bonus = 1,
+    Tournament = 2
+}
+export type ResponseEncodeConfig = {
+    categories: {
+        [sortId: number]: {
+            categoryId: number;
+            names: {
+                names: ResponseCategoryName[];
+            };
+        };
+    };
+    categoryGameIds: {
+        [sortId: number]: {
+            categoryId: number;
+            gameIds: ResponseGameIds;
+        };
+    };
+    popularCategories: {
+        [sortId: number]: {
+            countryId: number;
+            gameIds: ResponseGameIds;
+        };
+    };
+    subCategories: {
+        [sortId: number]: {
+            subCategoryId: number;
+            names: {
+                names: ResponseCategoryName[];
+            };
+        };
+    };
+    subCategoryGameIds: {
+        [sortId: number]: SubCategoryWithGame;
+    };
+    wagerCategories: WagerCategoryTypes;
+};
+export type WagerCategoryTypes = {
+    [inx: number]: {
+        wagerType: ECategoryWager;
+        gameIds: ResponseGameIds;
+    };
+};
+export type SubCategoryWithGame = {
+    categoryId: number;
+    subCategoryId: number;
+    gameIds: ResponseGameIds;
+};

package/dist/lib/store/casino/entities/categories/types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECategoryWager = exports.ECasinoCategoryIds = void 0;
+var ECasinoCategoryIds;
+(function (ECasinoCategoryIds) {
+    ECasinoCategoryIds[ECasinoCategoryIds["WagerSubCategoryTournament"] = -2] = "WagerSubCategoryTournament";
+    ECasinoCategoryIds[ECasinoCategoryIds["WagerSubCategoryBonus"] = -1] = "WagerSubCategoryBonus";
+    ECasinoCategoryIds[ECasinoCategoryIds["Wager"] = -1] = "Wager";
+    ECasinoCategoryIds[ECasinoCategoryIds["Crash"] = 1] = "Crash";
+    ECasinoCategoryIds[ECasinoCategoryIds["Slots"] = 2] = "Slots";
+    ECasinoCategoryIds[ECasinoCategoryIds["Casino"] = 3] = "Casino";
+    ECasinoCategoryIds[ECasinoCategoryIds["Turbo"] = 10] = "Turbo";
+    ECasinoCategoryIds[ECasinoCategoryIds["Popular"] = 99] = "Popular";
+    ECasinoCategoryIds[ECasinoCategoryIds["SubSlotsNew"] = 101] = "SubSlotsNew";
+    ECasinoCategoryIds[ECasinoCategoryIds["PopularSubCategory"] = 102] = "PopularSubCategory";
+    ECasinoCategoryIds[ECasinoCategoryIds["SubSlotsTop"] = 104] = "SubSlotsTop";
+    ECasinoCategoryIds[ECasinoCategoryIds["SubGameShow"] = 124] = "SubGameShow";
+})(ECasinoCategoryIds || (exports.ECasinoCategoryIds = ECasinoCategoryIds = {}));
+var ECategoryWager;
+(function (ECategoryWager) {
+    ECategoryWager[ECategoryWager["Bonus"] = 1] = "Bonus";
+    ECategoryWager[ECategoryWager["Tournament"] = 2] = "Tournament";
+})(ECategoryWager || (exports.ECategoryWager = ECategoryWager = {}));

package/dist/lib/store/casino/entities/games/index.d.ts

@@ -0,0 +1,32 @@
+import { CasinoServices } from 'store/casino/services';
+import { AdaptedGame, AdaptedGames, AllGames, InitialGames, SubscribeCasinoGameInfoSetting, SubscribeCasinoGameSetting, SubscribeCasinoProviderGamesSetting, SubscribeGameDemoModeProps, UpdatePlatformGamesProps } from './types';
+import { Observable } from 'service/observable';
+export declare class CasinoGames {
+    allGames: InitialGames;
+    desktopGames: AdaptedGames;
+    mobileGames: AdaptedGames;
+    vipGames: {
+        mobile: AdaptedGame[];
+        desktop: AdaptedGame[];
+    };
+    observableSettings: any;
+    initialGames: AllGames;
+    gameObservable: Observable;
+    services: CasinoServices;
+    constructor(services: CasinoServices);
+    updatePlatformGames({ mobile, desktop }: UpdatePlatformGamesProps): void;
+    setAllGames(games: InitialGames): void;
+    private sendGameUpdates;
+    private sendGameInfoUpdates;
+    private sendGameDemoModeUpdates;
+    private sendProviderGames;
+    sendUpdates(): void;
+    subscribeCasinoGames(props: SubscribeCasinoGameSetting): void;
+    unsubscribeGames(uid: string): void;
+    subscribeCasinoGameDemoMode(props: SubscribeGameDemoModeProps): void;
+    unsubscribeCasinoGameDemoMode(uid: string): void;
+    subscribeProviderGames(props: SubscribeCasinoProviderGamesSetting): void;
+    unsubscribeProviderGames(uid: string): void;
+    subscribeCasinoGameInfo(props: SubscribeCasinoGameInfoSetting): void;
+    unsubscribeCasinoGameInfo(uid: string): void;
+}

package/dist/lib/store/casino/entities/games/types.d.ts

@@ -0,0 +1,128 @@
+export type InitialGames = CasinoGame[];
+export type AllGames = {
+    [id: number]: AdaptedGame;
+};
+export declare enum ECasinoGameTypeImage {
+    Png = 0,
+    Jpg = 1,
+    Jpeg = 2,
+    Gif = 3
+}
+export type CasinoGame = {
+    categoryId: number;
+    hasMobile: number;
+    id: number;
+    name: string;
+    providerId: number;
+    typeImg: number;
+};
+export type AdaptedGame = Omit<CasinoGame, 'hasMobile'> & {
+    providerName: string;
+    hasMobile: boolean;
+    imageUrl: string;
+    sortId: number;
+    specialLabel: EAdaptedGameSpecialLabel;
+};
+export declare enum EAdaptedGameSpecialLabel {
+    Unknown = 0,
+    WagerBonus = 1,
+    WagerTournament = 2,
+    MultiWagering = 3
+}
+export type AdaptedGames = {
+    [id: number]: AdaptedGame;
+};
+export type UpdatePlatformGamesProps = {
+    mobile: AdaptedGames;
+    desktop: AdaptedGames;
+};
+export type CasinoGamesResponse = {
+    error?: string;
+    isLastPage: boolean;
+    games: AdaptedGame[];
+    compareKey?: string;
+    totalPages: number;
+};
+export type ObservableSettings = {
+    [uid: string]: ObservableSetting;
+};
+type ObservableSetting = ObservableSettingGame | ObservableSettingGames | ObservableSettingGameDemoMode | ObservableCasinoProviderGamesSetting;
+type ObservableSettingGame = {
+    isGameInfo: true;
+    gameId: number;
+    isMobile: boolean;
+};
+type ObservableSettingGameDemoMode = {
+    isGameDemoMode: true;
+    gameId: number;
+    isMobile: boolean;
+};
+type ObservableSettingGames = {
+    isGames: boolean;
+    isMobile: boolean;
+    categoryId: number | null;
+    subCategoryId: number | null;
+    page: number;
+    providerId: number | null;
+    limit: number;
+    excludeGameId?: number;
+};
+export type GetSearchingGamesProps = {
+    providerId: number;
+    isMobile: boolean;
+    excludeGameId?: number;
+    search: string;
+    sortFn: (g1: AdaptedGame, g2: AdaptedGame) => number;
+};
+export type ObservableCasinoProviderGamesSetting = {
+    isProviderGames: boolean;
+    page: number;
+    search?: string;
+    providerId?: number | null;
+    excludeGameId?: number;
+    limit: number;
+    isMobile: boolean;
+    sortFn?: (a: AdaptedGame, b: AdaptedGame) => number;
+};
+export type SubscribeCasinoGamesSetting = {
+    categoryId: number | null;
+    subCategoryId: number | null;
+    page: number;
+    search?: string;
+    providerId?: number | null;
+    excludeGameId?: number;
+    limit: number;
+    isMobile: boolean;
+    sortFn?: (a: AdaptedGame, b: AdaptedGame) => number;
+};
+export type SubscribeCasinoGameSetting = {
+    uid: string;
+    callback: (d: CasinoGamesResponse) => void;
+    options: SubscribeCasinoGamesSetting;
+};
+export type SubscribeGameDemoModeProps = {
+    uid: string;
+    gameId: number;
+    isMobile: boolean;
+    callback: (status: {
+        status: boolean;
+    }) => void;
+};
+export type SubscribeCasinoProviderGamesSetting = {
+    isMobile: boolean;
+    providerId: number;
+    limit: number;
+    page: number;
+    search: string;
+    excludeGameId?: number;
+    callback: (games: any) => void;
+    uid: string;
+};
+export type SubscribeCasinoGameInfoSetting = {
+    uid: string;
+    isMobile: boolean;
+    force: boolean;
+    gameId: number;
+    callback: (d: CasinoGamesResponse) => void;
+};
+export {};

package/dist/lib/store/casino/entities/games/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EAdaptedGameSpecialLabel = exports.ECasinoGameTypeImage = void 0;
+var ECasinoGameTypeImage;
+(function (ECasinoGameTypeImage) {
+    ECasinoGameTypeImage[ECasinoGameTypeImage["Png"] = 0] = "Png";
+    ECasinoGameTypeImage[ECasinoGameTypeImage["Jpg"] = 1] = "Jpg";
+    ECasinoGameTypeImage[ECasinoGameTypeImage["Jpeg"] = 2] = "Jpeg";
+    ECasinoGameTypeImage[ECasinoGameTypeImage["Gif"] = 3] = "Gif";
+})(ECasinoGameTypeImage || (exports.ECasinoGameTypeImage = ECasinoGameTypeImage = {}));
+var EAdaptedGameSpecialLabel;
+(function (EAdaptedGameSpecialLabel) {
+    EAdaptedGameSpecialLabel[EAdaptedGameSpecialLabel["Unknown"] = 0] = "Unknown";
+    EAdaptedGameSpecialLabel[EAdaptedGameSpecialLabel["WagerBonus"] = 1] = "WagerBonus";
+    EAdaptedGameSpecialLabel[EAdaptedGameSpecialLabel["WagerTournament"] = 2] = "WagerTournament";
+    EAdaptedGameSpecialLabel[EAdaptedGameSpecialLabel["MultiWagering"] = 3] = "MultiWagering";
+})(EAdaptedGameSpecialLabel || (exports.EAdaptedGameSpecialLabel = EAdaptedGameSpecialLabel = {}));

package/dist/lib/store/casino/entities/jackpots/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const JACKPOT_SUM_SETTINGS: {
+    U: number;
+    A: number;
+    B: number;
+    C: number;
+    D: number;
+    E: number;
+    F: number;
+    1: number;
+    2: number;
+    3: number;
+    4: number;
+    5: number;
+};

package/dist/lib/store/casino/entities/jackpots/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JACKPOT_SUM_SETTINGS = void 0;
+exports.JACKPOT_SUM_SETTINGS = {
+    U: 0,
+    A: 10,
+    B: 50,
+    C: 100,
+    D: 500,
+    E: 1000,
+    F: 5000,
+    1: 0.8,
+    2: 1.2,
+    3: 1.4,
+    4: 1.6,
+    5: 1.8,
+};

package/dist/lib/store/casino/entities/jackpots/index.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { UpdateData } from 'service/observable/type';
+import { ObservableEntity } from 'service/observableEntity';
+import { CasinoServices } from 'store/casino/services';
+import { JackpotInfo, JackpotSettings, JackpotSubscribes } from './types';
+import { ERequestStatus } from 'socket/types';
+export declare class Jackpots extends ObservableEntity<undefined> {
+    _jackpots: JackpotInfo[];
+    _requestStatus: ERequestStatus;
+    timer: NodeJS.Timeout | null;
+    service: CasinoServices;
+    jackpotSettings: JackpotSettings | undefined;
+    constructor(casinoService: CasinoServices, settings: JackpotSettings);
+    set requestStatus(value: ERequestStatus);
+    get requestStatus(): ERequestStatus;
+    set jackpots(jackpots: JackpotInfo[]);
+    get jackpots(): JackpotInfo[];
+    fetchJackpots(): Promise<void>;
+    sendActiveJackpots(): UpdateData | null;
+    sendHistoryJackpots(): UpdateData | null;
+    sendJackpotInfo(jackpotId: string, isMobile: boolean): UpdateData | null;
+    sendUpdateEntity(d: JackpotSubscribes): UpdateData | null;
+}

package/dist/lib/store/casino/entities/jackpots/types.d.ts

@@ -0,0 +1,48 @@
+import { BaseObservableSubscriber } from 'service/observable/type';
+import { AdaptedGame } from '../games/types';
+export type JackpotSettings = {
+    path: string;
+    keys: [[string, string], [string, string], [string, string]];
+};
+export type JackpotResponse = {
+    uid: string;
+    gameIds: number[];
+    provider: string;
+    jackpotName: string;
+    type: keyof typeof EJackpotType;
+}[];
+export type JackpotInfo = {
+    startTime: number;
+    endTime: number;
+    jackpotName: string;
+    provider: string;
+    gameIds: number[];
+    id: string;
+    minSum: number;
+    maxJackpotSum: number;
+    type: EJackpotType;
+};
+export type JackpotHookInfo = Omit<JackpotInfo, 'endTime' | 'maxJackpotSum' | 'minSum' | 'gameIds' | 'provider'> & {
+    currentValue: number;
+};
+export type JackpotDetails = JackpotHookInfo & {
+    games: AdaptedGame[];
+};
+export type HistoryJackpotDetails = JackpotHookInfo & {
+    userId: string;
+};
+export declare enum EJackpotType {
+    Minor = 0,
+    Major = 1,
+    Grand = 2
+}
+export type JackpotSubscribes = BaseObservableSubscriber & SubscribeHookType;
+export type SubscribeHookType = {
+    jackpotId: string;
+    isMobile: boolean;
+} | {
+    jackpotId?: string;
+    isMobile?: boolean;
+} | {
+    isHistory: boolean;
+};

package/dist/lib/store/casino/entities/jackpots/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EJackpotType = void 0;
+var EJackpotType;
+(function (EJackpotType) {
+    EJackpotType[EJackpotType["Minor"] = 0] = "Minor";
+    EJackpotType[EJackpotType["Major"] = 1] = "Major";
+    EJackpotType[EJackpotType["Grand"] = 2] = "Grand";
+})(EJackpotType || (exports.EJackpotType = EJackpotType = {}));

package/dist/lib/store/casino/entities/lastWinners/index.d.ts

@@ -0,0 +1,23 @@
+import { BetType, ReturnSubscribeCasinoLastWinnersProps, SubscribeCasinoLastWinnersProps } from './types';
+import { CasinoServices } from 'store/casino/services';
+import { ObservableEntity } from 'service/observableEntity';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+export declare class LastWinners extends ObservableEntity<undefined> {
+    services: CasinoServices;
+    lastWinners: ReturnSubscribeCasinoLastWinnersProps[];
+    lastTimeUpdate: number;
+    timers: null | ReturnType<typeof setTimeout>;
+    constructor(services: CasinoServices);
+    clearAllTimers(): void;
+    private startUpdateTime;
+    private getWinnerInfo;
+    private sendLastWinnersUpdate;
+    sendUpdateEntity(info: BaseObservableSubscriber & {
+        limit: number;
+        type: BetType;
+        fullUpdateTime?: number;
+        isMobile?: boolean;
+    }): UpdateData | null;
+    subscribeCasinoLastWinners(props: SubscribeCasinoLastWinnersProps): void;
+    unsubscribeCasinoLastWinnerEntities(uid: string): void;
+}

package/dist/lib/store/casino/entities/lastWinners/types.d.ts

@@ -0,0 +1,14 @@
+import { AdaptedGame } from '../games/types';
+export type SubscribeCasinoLastWinnersProps = {
+    uid: string;
+    callback: (d: ReturnSubscribeCasinoLastWinnersProps[]) => void;
+    limit: number;
+    type: 'vipBet' | 'base';
+    fullUpdateTime?: number;
+};
+export type BetType = 'vipBet' | 'base';
+export type ReturnSubscribeCasinoLastWinnersProps = {
+    gameInfo: AdaptedGame;
+    prize: number;
+    clientId: string;
+};