react-memory-optimization 0.0.1

package/dist/lib/service/responseAdapter/types.d.ts

@@ -0,0 +1,164 @@
+import { Ticket } from 'store/betting/entities/tickets/types';
+import { ERequestIds, ICurrency, ITopEvent } from '../../binary/types';
+import { Operation } from '../../store/operations/types';
+import { LotteryResponseHistoryTicket, LotteryTicket } from 'store/lottery/types';
+import { ResponseHistoryTicket } from 'store/lottery/entities/history/types';
+import { BettingSettings } from 'store/betting/types';
+import { CasinoHistoryBet } from 'store/operations/entities/casinoHistory/types';
+export declare enum EKYCStatus {
+    NotVerified = 0,
+    NeedKYC = 1,
+    Pending = 2,
+    Accepted = 3,
+    Rejected = 4,
+    Ignore = 5
+}
+export type AdaptedCasinoGameOperationsProps = {
+    requestId: number;
+    operationLength: number;
+    operations: {
+        [indx: number]: {
+            operation: CasinoHistoryBet;
+        };
+    };
+};
+export type HandlePaymentOperationsProps = {
+    requestId: ERequestIds;
+    operations: {
+        [inx: number]: {
+            operation: Operation;
+        };
+    };
+};
+export type DecodeBetSlipResponse = {
+    requestId: ERequestIds;
+} & ({
+    isCouponError: true;
+} | {
+    bets: ResponseBet[];
+    tickets: Ticket[];
+    balance: DecodeBalanceUpdate;
+});
+export type DecodeBalanceUpdate = {
+    bonusBalance: number;
+    deposit: number;
+    inGameBalance: number;
+    inGameBonusBalance: number;
+    inGameTotoBalance: number;
+    loyaltyLvl: number;
+    loyaltyWager: number;
+    mainBalance: number;
+    points: number;
+    successDepositCnt: number;
+};
+export type ResponseBet = {
+    inx: number;
+    isError: true;
+};
+export type HandleBetHistoryProps = {
+    requestId: ERequestIds;
+    betHistory: Ticket[];
+};
+export type LotteryTicketsResponse = {
+    requestId: ERequestIds;
+    lotteries: {
+        [id: number]: LotteryTicket;
+    };
+};
+type ReadTotalDeposit = {
+    dayDeposit: number;
+    monthDeposit: number;
+    needRolled: number;
+    rolledWithTax: number;
+    weekDeposit: number;
+};
+type BalanceInfoResponse = {
+    bonusBalance: number;
+    deposit: number;
+    inGameBalance: number;
+    inGameBonusBalance: number;
+    inGameTotoBalance: number;
+    loyaltyLvl: number;
+    loyaltyWager: number;
+    mainBalance: number;
+    points: number;
+    successDepositCnt: number;
+};
+export type HandleHistoryTickets = {
+    totalDeposit: ReadTotalDeposit;
+    balanceInfo: BalanceInfoResponse;
+    requestId: ERequestIds;
+    tickets: {
+        [inx: number]: LotteryResponseHistoryTicket;
+    };
+};
+export type HandleBuyTicketLotteryResponse = {
+    response: number;
+    requestId: ERequestIds;
+};
+export type HandleHistoryLotteryTickets = {
+    requestId: ERequestIds.LotteryHistoryTicket;
+    tickets: {
+        [inx: number]: ResponseHistoryTicket;
+    };
+};
+export type HandleOperationsUpdateProps = {
+    balanceInfo: BalanceInfoResponse;
+    operations: {
+        [inx: number]: {
+            operation: unknown;
+        };
+    };
+    requestId: number;
+    totalDeposit: ReadTotalDeposit;
+};
+export type HandleTicketResultSummaryProps = {
+    requestId: number;
+    id: number;
+    settlementOdd: number;
+    summary: string;
+    status: number;
+};
+export type HandleTicketResultProps = {
+    requestId: number;
+    id: number;
+    payout: number;
+    points: number;
+    bonusBalance: number;
+    status: number;
+    acceptedOdd: number;
+    settlementOdd: number;
+    balance: BalanceInfoResponse;
+};
+export type HandleAdditionalUserInfoProps = {
+    availableOperationDates: {
+        [inx: number]: {
+            timestamp: number;
+        };
+    };
+    availableTicketDates: {
+        [inx: number]: {
+            timestamp: number;
+        };
+    };
+    balance: BalanceInfoResponse;
+    bonusPackInfo: any;
+    casinoDates: any;
+    currentOperations: {
+        [indx: number]: {
+            timestamp: Operation;
+        };
+    };
+    inGameTickets: any[];
+    requestId: number;
+    totalDeposit: any;
+};
+export type HandleBackOfficeResponse = {
+    backOfficeSettings: BackOfficeSettings;
+};
+export type BackOfficeSettings = {
+    registrationCurrencies: ICurrency[];
+    topEvents: ITopEvent[];
+    settings: BettingSettings;
+};
+export {};

package/dist/lib/service/responseAdapter/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EKYCStatus = void 0;
+var EKYCStatus;
+(function (EKYCStatus) {
+    EKYCStatus[EKYCStatus["NotVerified"] = 0] = "NotVerified";
+    EKYCStatus[EKYCStatus["NeedKYC"] = 1] = "NeedKYC";
+    EKYCStatus[EKYCStatus["Pending"] = 2] = "Pending";
+    EKYCStatus[EKYCStatus["Accepted"] = 3] = "Accepted";
+    EKYCStatus[EKYCStatus["Rejected"] = 4] = "Rejected";
+    EKYCStatus[EKYCStatus["Ignore"] = 5] = "Ignore";
+})(EKYCStatus || (exports.EKYCStatus = EKYCStatus = {}));

package/dist/lib/service/responseAdapter/utils.d.ts

@@ -0,0 +1,27 @@
+import { ResponseHistoryTicket } from 'store/lottery/entities/history/types';
+import { AdaptedCasinoTournamentProps, InitialTournaments } from 'store/casino/entities/casinoTournaments/types';
+export declare const adaptedBalance: (balance: any) => any;
+export declare const adaptedUserPermissions: ({ bonusPackInfo, isVerificationIgnored, verificationStatus, }: any) => {
+    isBonusBan: boolean;
+    isBetsPause: boolean;
+    minDepOdd: number;
+    isLoginBan: boolean;
+    isWithdrawalBan: boolean;
+    isWithDrawalPostponed: boolean;
+    isCashOutBan: boolean;
+    verificationStatus: any;
+};
+export declare const adaptedBonusPackInfo: (bonusPackInfo: any) => {
+    isBonusBan: boolean;
+    isBetsPause: boolean;
+    minDepOdd: number;
+    isLoginBan: boolean;
+    isWithdrawalBan: boolean;
+    isWithDrawalPostponed: boolean;
+    isCashOutBan: boolean;
+    verificationStatus: any;
+};
+export declare const adaptedLotteryTickets: (tickets: {
+    [inx: number]: ResponseHistoryTicket;
+}) => ResponseHistoryTicket[];
+export declare const adaptedCasinoTournament: (result: AdaptedCasinoTournamentProps) => InitialTournaments;

package/dist/lib/service/responseAdapter/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptedCasinoTournament = exports.adaptedLotteryTickets = exports.adaptedBonusPackInfo = exports.adaptedUserPermissions = exports.adaptedBalance = void 0;
+const types_1 = require("./types");
+const types_2 = require("store/casino/entities/casinoTournaments/types");
+const adaptedBalance = (balance) => (Object.assign(Object.assign({}, balance), { loyaltyWager: balance.loyaltyWager / 100, successDepositCnt: balance.successDepositCnt, inGameBalance: balance.inGameBalance / 100, inGameBonusBalance: balance.inGameBonusBalance / 100, inGameTotoBalance: balance.inGameTotoBalance / 100, points: balance.points / 100, deposit: balance.deposit / 100, 
+    // bonusBalance: balance.bonusBalance / 100, -- betting
+    bonusBalance: balance.inGameTotoBalance / 100, mainBalance: balance.mainBalance / 100 }));
+exports.adaptedBalance = adaptedBalance;
+const adaptedUserPermissions = ({ bonusPackInfo, isVerificationIgnored, verificationStatus, }) => ({
+    isBonusBan: Boolean(bonusPackInfo.isBonusBan),
+    isBetsPause: Boolean(bonusPackInfo.isBetsPause),
+    minDepOdd: bonusPackInfo.minDepOdd * 0.25,
+    isLoginBan: Boolean(bonusPackInfo.isLoginBan),
+    isWithdrawalBan: Boolean(bonusPackInfo.isWithdrawalBan),
+    isWithDrawalPostponed: Boolean(bonusPackInfo.isWithDrawalPostponed),
+    isCashOutBan: Boolean(bonusPackInfo.isCashOutBan),
+    verificationStatus: isVerificationIgnored
+        ? types_1.EKYCStatus.Ignore
+        : verificationStatus,
+});
+exports.adaptedUserPermissions = adaptedUserPermissions;
+const adaptedBonusPackInfo = (bonusPackInfo) => {
+    const { isVerificationIgnored, verificationStatus } = bonusPackInfo;
+    return (0, exports.adaptedUserPermissions)({
+        bonusPackInfo,
+        isVerificationIgnored,
+        verificationStatus,
+    });
+};
+exports.adaptedBonusPackInfo = adaptedBonusPackInfo;
+const adaptedLotteryTickets = (tickets) => Object.values(tickets).map(({ ticket }) => (Object.assign(Object.assign({}, ticket), { amount: ticket.amount / 100, bets: ticket.bets.map((b) => (Object.assign(Object.assign({}, b), { payout: b.payout / 100, saleDate: b.saleDate * 1000 }))) })));
+exports.adaptedLotteryTickets = adaptedLotteryTickets;
+const adaptedCasinoTournament = (result) => {
+    let activeTournaments = null;
+    // TODO
+    const finishedTournaments = {}; // TODO
+    Object.values(result.tournaments).forEach(({ tournament }) => {
+        const { startDate, endDate, 
+        // @ts-ignore
+        players = [], amount, status, id, } = tournament;
+        const data = {
+            id,
+            status,
+            startDate: startDate * 1000,
+            endDate: endDate * 1000,
+            amount: amount / 100,
+        };
+        const adaptedPlayers = players.map((p) => (Object.assign(Object.assign({}, p), { rolled: p.rolled / 100, payout: p.payout / 100, payoutBonus: p.payoutBonus / 100 })));
+        const tournamentInfo = Object.assign(Object.assign({}, data), { players: adaptedPlayers, playerLength: adaptedPlayers.length });
+        if (types_2.ECasinoTournamentStatus.Active === status) {
+            // this.activeTournament.updateActiveTournamentInfo(data, adaptedPlayers);
+            activeTournaments = tournamentInfo;
+            return true;
+        }
+        finishedTournaments[tournament.id] = tournamentInfo;
+    });
+    return {
+        activeTournaments,
+        finishedTournaments,
+    };
+};
+exports.adaptedCasinoTournament = adaptedCasinoTournament;

package/dist/lib/socket/index.d.ts

@@ -0,0 +1,253 @@
+import { ESocketCallbackStep, ISocketSettings, SocketInterface, TBettingSettings, TCasinoSettings } from './types';
+import { ResponseAdapter } from '../service/responseAdapter';
+import { SubscribeSportInfoBySportIdProps, SubscribeSportsProps } from '../store/betting/entities/sports/types';
+import { SubscribeCountryInfoProps, SubscribeMinDepositInfoProps, SubscribeUserCurrencyInfoProps, SubscribeUserStateProps } from '../store/user/types';
+import { ReadModuleKeys, ReadModuleType } from '../binary/types';
+import { CashOutTicketProps, SubscribeComposeTransactionsProps } from './methodTypes';
+import { SubscribeBettingStatusProps } from '../store/betting/types';
+import { SubscribeBettingTopTournamentsProps, SubscribeBettingTournamentsByCategoryIdOrSportIdProps, SubscribeBettingTournamentsByIdProps } from '../store/betting/entities/tournaments/types';
+import { SubscribeBettingEventsByTournamentIdProps, SubscribeBettingTopEventsProps, SubscribeEventDetailsMarketTabs, SubscribeEventDetailsMarketsByGroupIdProps, SubscribeEventShortInfoProps, SubscribeLineEntitiesProps, SubscribeOdd, SubscribeEventEntitiesProps } from '../store/betting/entities/events/types';
+import { SubscriberCategoriesProps, SubscriberCategoryProps } from '../store/betting/entities/categories/types';
+import { SubscribeLiveScoreProps } from 'store/betting/entities/events/live/types';
+import { AddBetProps, RemoveBetProps, SetBetSlipStakeProps, SubscribeBetSlipBaseProps, SubscribeBetSlipMaxToWinProps, SubscribeBettingBetSlipCounterProps, SubscribeSelectedOdd, SubscribeSpecialBetOdd } from '../store/betting/entities/betslip/types';
+import { SubscribeCasinoCategoriesHomePageProps, SubscribeCasinoCategoriesProps, SubscribeCasinoSubCategoriesProps } from 'store/casino/entities/categories/types';
+import { SubscribeCasinoGameInfoSetting, SubscribeCasinoGameSetting, SubscribeCasinoProviderGamesSetting, SubscribeGameDemoModeProps } from 'store/casino/entities/games/types';
+import { ObservableProviderGameCountSetting, ObservableProviderInfoSetting, ObservableProvidersSetting } from 'store/casino/entities/providers/types';
+import { PrepareFavoriteEntitiesForSavingProps, SubscribeFavoriteGameProps, SubscribeFavoriteGamesProps } from 'store/user/entities/favorites/types';
+import { SocketServices } from './services';
+import { SubscribeHistoryTicketsInfoProps, SubscribeTicketInfoProps, SubscribeTicketsProps } from 'store/betting/entities/tickets/types';
+import { SubscribeCasinoLastWinnersProps } from 'store/casino/entities/lastWinners/types';
+import { SubscribeFreeCashTickets } from 'store/lottery/entities/freeCash/types';
+import { SubscribeInstantTickets } from 'store/lottery/entities/instantCash/types';
+import { SubscribeBuyTicketInfoProps } from 'store/lottery/types';
+import { SubscribeLotteryAvailableForBuyingProps, SubscribeLotteryHistoryProps } from 'store/lottery/entities/history/types';
+import { ExperimentalFeatures } from 'service/experimental';
+import { BaseObservableSubscriber } from 'service/observable/type';
+import { AvatarType, BuyAvatarProps } from 'store/user/entities/avatar/types';
+import { BuyHeroAvatar } from 'store/user/entities/hamster/types';
+import { UpdateVipClubEntityKey } from 'store/operations/entities/vipClub/types';
+import { CashBonusChannelType } from 'store/operations/entities/cashBonuses/types';
+import { JackpotSettings } from 'store/casino/entities/jackpots/types';
+import { CasinoHistoryGamesSubscriber } from 'store/operations/entities/casinoHistory/types';
+export declare class Socket implements SocketInterface {
+    socketServices: SocketServices;
+    initialSettings: ISocketSettings;
+    delayedSubscribes: (() => boolean)[];
+    socketUrl: string;
+    appType: number;
+    language: string;
+    scheme: any;
+    updateSocketStatus: (t: ESocketCallbackStep) => void;
+    decodedDataCallback: any;
+    webSocket: null | WebSocket;
+    _transport: null | ResponseAdapter;
+    casinoSettings: TCasinoSettings;
+    bettingSettings: TBettingSettings;
+    experimentalFeatures: ExperimentalFeatures;
+    _socketStatus: ESocketCallbackStep;
+    decodeTasks: {
+        key: string;
+        result: any;
+    }[];
+    constructor(settings: ISocketSettings);
+    set socketStatus(s: ESocketCallbackStep);
+    get socketStatus(): ESocketCallbackStep;
+    set transport(transport: ResponseAdapter);
+    get transport(): ResponseAdapter;
+    sendDecodeDataInfo(decodeFn: (key: string, result: any) => void): (key: string, result: any) => void;
+    init(): void;
+    onOpen(): void;
+    onMessage(event: {
+        data: Iterable<number>;
+    }): void;
+    onClose(): void;
+    onError(): void;
+    sendCommand(key: string, data: {
+        [key: string]: string | number | any[];
+    }): void;
+    getSpecificScheme(key: ReadModuleKeys): ReadModuleType[];
+    decode(stream: Uint8Array, step: number): void;
+    subscribeEntity(method: () => boolean): boolean;
+    logout(): void;
+    subscribeCountryInfo(props: SubscribeCountryInfoProps): boolean;
+    subscribeMinDepOdd(props: SubscribeMinDepositInfoProps): boolean;
+    subscribeUserCurrencyInfo(props: SubscribeUserCurrencyInfoProps): boolean;
+    subscribeUserState(props: SubscribeUserStateProps): boolean;
+    subscribeUserInfo(props: SubscribeUserStateProps): boolean;
+    unsubscribeUserEntity(uid: string): boolean;
+    subscribeBalanceInfo(props: BaseObservableSubscriber): boolean;
+    subscribeBonusBalanceCoins(props: BaseObservableSubscriber): boolean;
+    unsubscribeBalanceEntity(uid: string): boolean;
+    subscribeJackpotsEntity(props: BaseObservableSubscriber & JackpotSettings): boolean;
+    unsubscribeJackpotsEntity(uid: string): boolean;
+    subscribeCasinoCategories(props: SubscribeCasinoCategoriesProps): boolean;
+    subscribeCasinoSubCategories(props: SubscribeCasinoSubCategoriesProps): boolean;
+    subscribeCasinoGames(props: SubscribeCasinoGameSetting): boolean;
+    unsubscribeCasinoGames(uid: string): boolean;
+    subscribeCasinoGameInfo(props: SubscribeCasinoGameInfoSetting): boolean;
+    unsubscribeCasinoGameInfo(uid: string): boolean;
+    subscribeProviderGames(props: SubscribeCasinoProviderGamesSetting): boolean;
+    unsubscribeProviderGames(uid: string): boolean;
+    subscribeGameDemoMode(props: SubscribeGameDemoModeProps): boolean;
+    unsubscribeGameDemoMode(uid: string): boolean;
+    subscribeCasinoProviders(data: BaseObservableSubscriber | ObservableProvidersSetting | ObservableProviderInfoSetting | ObservableProviderGameCountSetting): boolean;
+    unsubscribeCasinoProviders(uid: string): boolean;
+    subscribeCasinoCategoryInfo(props: any): boolean;
+    unsubscribeCasinoCategoryEntity(uid: string): boolean;
+    subscribeCasinoCategoriesHomePage(props: SubscribeCasinoCategoriesHomePageProps): boolean;
+    subscribeCasinoLastWinners(props: SubscribeCasinoLastWinnersProps): boolean;
+    unsubscribeCasinoLastWinnerEntities(uid: string): boolean;
+    subscribeCasinoBattles(props: BaseObservableSubscriber & {
+        isFinished: boolean;
+    }): boolean;
+    unsubscribeCasinoBattles(uid: string): boolean;
+    subscribeCasinoGameHistory(props: CasinoHistoryGamesSubscriber): boolean;
+    unsubscribeCasinoGameHistory(uid: string): boolean;
+    subscribeTransactions(props: SubscribeComposeTransactionsProps): boolean;
+    unsubscribeTransactions(uid: string): boolean;
+    subscribeVipClubEntities(props: BaseObservableSubscriber & UpdateVipClubEntityKey): boolean;
+    unsubscribeVipClubEntities(uid: string): boolean;
+    subscribeVipClubOperations(props: BaseObservableSubscriber & UpdateVipClubEntityKey): boolean;
+    unsubscribeVipClubOperations(uid: string): boolean;
+    subscribeBonuses(props: BaseObservableSubscriber & {
+        isActive: boolean;
+    }): boolean;
+    unsubscribeBonuses({ uid, isActive }: {
+        uid: string;
+        isActive: boolean;
+    }): boolean;
+    subscribeCashBonuses(props: BaseObservableSubscriber & {
+        channelType?: CashBonusChannelType;
+    }): boolean;
+    unsubscribeCashBonuses(uid: string): boolean;
+    subscribeTournamentBonuses(props: BaseObservableSubscriber & {
+        isActive?: boolean;
+    }): boolean;
+    unsubscribeTournamentBonuses(uid: string): boolean;
+    saveToFavoriteEntities(props: PrepareFavoriteEntitiesForSavingProps): boolean;
+    subscribeIsFavoriteGame(props: SubscribeFavoriteGameProps): boolean;
+    subscribeFavoriteGames(props: SubscribeFavoriteGamesProps): boolean;
+    unsubscribeFavoriteEntity(uid: string): boolean;
+    handleSaveUserAvatar(info: AvatarType | null): boolean;
+    handleBuyAvatar(info: BuyAvatarProps): boolean;
+    handleBuyHero(info: BuyHeroAvatar): boolean;
+    subscribeUserAvatar(props: BaseObservableSubscriber): boolean;
+    subscribeUserAvatars(props: BaseObservableSubscriber): boolean;
+    unsubscribeAvatar(uid: string): boolean;
+    subscribeLotteryFreeCash(props: SubscribeFreeCashTickets): boolean;
+    unsubscribeLotteryFreeCash(uid: string): boolean;
+    subscribeLotteryInstantCash(props: SubscribeInstantTickets): boolean;
+    unsubscribeLotteryInstantCashEntity(uid: string): boolean;
+    subscribeBuyTicketInfo(props: SubscribeBuyTicketInfoProps): boolean;
+    unsubscribeBuyTicketInfo(uid: string): boolean;
+    subscribeLotteryHistory(props: SubscribeLotteryHistoryProps): boolean;
+    subscribeLotteryAvailableForBuying(props: SubscribeLotteryAvailableForBuyingProps): boolean;
+    unsubscribeLotteriesHistoryEntities(uid: string): boolean;
+    subscribeBettingStatus(data: SubscribeBettingStatusProps): boolean;
+    unsubscribeBettingStatus(uid: string): boolean;
+    subscribeBettingSettingsStatus(data: SubscribeBettingStatusProps): boolean;
+    unsubscribeBettingSettingsStatus(uid: string): boolean;
+    subscribeBettingTopTournaments(data: SubscribeBettingTopTournamentsProps): boolean;
+    unsubscribeBettingTopTournaments(uid: string): boolean;
+    subscribeBettingTournamentsByCategoryIdOrSportId(props: SubscribeBettingTournamentsByCategoryIdOrSportIdProps): boolean;
+    unsubscribeBettingTournamentsByCategoryIdOrSportId(uid: string): boolean;
+    subscribeBettingTournamentById(props: SubscribeBettingTournamentsByIdProps): boolean;
+    unsubscribeBettingTournamentById(uid: string): boolean;
+    subscribeBettingTopEvents(data: SubscribeBettingTopEventsProps): boolean;
+    unsubscribeBettingTopEvents(uid: string): boolean;
+    subscribeSports(props: SubscribeSportsProps): boolean;
+    unsubscribeSportEntities(uid: string): boolean;
+    subscribeSportInfoBySportId(props: SubscribeSportInfoBySportIdProps): boolean;
+    subscribeBettingCategories(props: SubscriberCategoriesProps): boolean;
+    unsubscribeBettingCategories(uid: string): boolean;
+    subscribeCategoryById(props: SubscriberCategoryProps): boolean;
+    unsubscribeCategoryById(uid: string): boolean;
+    subscribeEventsByTournamentId(props: SubscribeBettingEventsByTournamentIdProps): boolean;
+    unsubscribeEventsByTournamentId(uid: string): boolean;
+    subscribeOdd(props: SubscribeOdd): boolean;
+    unsubscribeOdd(uid: string, isPrematch: boolean): boolean;
+    subscribeEventEntities(props: SubscribeEventEntitiesProps): boolean;
+    unsubscribeEventEntities(uid: string, isPrematch: boolean): boolean;
+    subscribeShortEventInfo(props: SubscribeEventShortInfoProps): boolean;
+    unsubscribeShortEventInfo(uid: string, isPrematch: boolean): boolean;
+    subscribeEventDetailsMarketTabs(props: SubscribeEventDetailsMarketTabs): boolean;
+    unsubscribeEventDetailsMarketTabs(uid: string, isPrematch: boolean): boolean;
+    subscribeEventDetailsMarketsByGroupId(props: SubscribeEventDetailsMarketsByGroupIdProps): boolean;
+    unsubscribeEventDetailsMarketsByGroupId(uid: string, isPrematch: boolean): boolean;
+    subscribeEventScore(props: SubscribeLiveScoreProps): boolean;
+    unsubscribeEventScore(uid: string): boolean;
+    subscribeFilterMarkets(props: any): boolean;
+    unsubscribeFilterMarkets(uid: string): boolean;
+    subscribeFilterMarketNames(props: any): boolean;
+    unsubscribeFilterMarketNames(uid: string): boolean;
+    subscribeLineEntities(props: SubscribeLineEntitiesProps): boolean;
+    unsubscribeLineEntities(uid: string, isPrematch: boolean): boolean;
+    subscribeCashOutTickets(props: SubscribeTicketsProps): boolean;
+    subscribeInGameLiveTickets(props: SubscribeTicketsProps): boolean;
+    subscribeInGameTickets(props: SubscribeTicketsProps): boolean;
+    subscribeTicketInfo(props: SubscribeTicketInfoProps): boolean;
+    subscribeHistoryTickets(props: SubscribeHistoryTicketsInfoProps): boolean;
+    unsubscribeTicketsEntity(uid: string): boolean;
+    ticketCashOut(props: CashOutTicketProps): boolean;
+    subscribeBettingBetSlipCounter(props: SubscribeBettingBetSlipCounterProps): boolean;
+    subscribeSelectedOdd(props: SubscribeSelectedOdd): boolean;
+    subscribeBetSlipBets(props: SubscribeBetSlipBaseProps): boolean;
+    subscribeBetSlipStatus(props: SubscribeBetSlipBaseProps): boolean;
+    subscribeBetSlipShortInfo(props: SubscribeBetSlipBaseProps): boolean;
+    subscribeBetSlipMaxToWin(props: SubscribeBetSlipMaxToWinProps): boolean;
+    subscribeSpecialBetOdd(props: SubscribeSpecialBetOdd): boolean;
+    subscribeBetSlipBetsAmount(props: Omit<SubscribeBetSlipBaseProps, 'betUid'>): boolean;
+    unsubscribeBetSlipEntities(uid: string): boolean;
+    addBet(props: AddBetProps): boolean;
+    removeBet(props: RemoveBetProps): boolean;
+    removeAllBets(): boolean;
+    setBetSlipStake(props: SetBetSlipStakeProps): boolean;
+    placeBetSlip(): boolean;
+    acceptErrors(): boolean;
+    setSystemRang(rang: number): boolean;
+    subscribeReferralLink(props: BaseObservableSubscriber): boolean;
+    subscribeReferralBalance(props: BaseObservableSubscriber): boolean;
+    subscribeReferralClient(props: BaseObservableSubscriber): boolean;
+    referralWithdraw(amount: number): boolean;
+    unsubscribeReferralEntity(uid: string): boolean;
+    getLootBoxResult(amount: number): false | {
+        isError: boolean;
+        prize: number;
+        isWin: boolean;
+        description: string;
+        isRealMoney?: undefined;
+    } | {
+        isWin: boolean;
+        prize: number;
+        description: string;
+        isRealMoney: boolean;
+        isError?: undefined;
+    } | {
+        isWin: boolean;
+        prize: number;
+        isRealMoney: boolean;
+        isError?: undefined;
+        description?: undefined;
+    } | {
+        prize: number;
+        isWin: boolean;
+        isError?: undefined;
+        description?: undefined;
+        isRealMoney?: undefined;
+    };
+    getLootBoxGameSettings(): false | import("../store/user/entities/lootBox/types").LootBoxGameSettings;
+    getWheelItems(): number[];
+    getWheelResult(): {
+        value: number;
+        result: number;
+    };
+    boostEnergy(): boolean;
+    changeCoins(sellCoins: number, receiveCoins: number): boolean;
+    subscribeHamster(props: BaseObservableSubscriber): boolean;
+    unsubscribeHamster(uid: string): boolean;
+    setActiveDailyTask(id: string): boolean;
+    subscribeDailyTasks(props: BaseObservableSubscriber): boolean;
+    subscribeActiveDailyTask(props: BaseObservableSubscriber): boolean;
+    unsubscribeDailyTasks(uid: string): boolean;
+    handleActivateCode(code: string): boolean;
+}

package/dist/lib/socket/methodTypes.d.ts

@@ -0,0 +1,23 @@
+import { BaseObservableSubscriber } from 'service/observable/type';
+import { Operation, TransactionFilterType } from 'store/operations/types';
+export type SubscribeComposeTransactionsProps = BaseObservableSubscriber & {
+    range: [number, number];
+    types: TransactionFilterType[];
+    withGameInfo?: boolean;
+};
+export type GetCasinoGameResponse = {
+    providerName: string;
+    providerId: number;
+    id: number;
+    imageUrl: string;
+    name: string;
+};
+export type GetAvailableBonusesResponse = {
+    bonusOnDeposit: Operation[];
+    freeSpins: Operation[];
+};
+export type CashOutTicketProps = {
+    ticketId: number;
+    outputStake: number;
+    remainingStake: number;
+};

package/dist/lib/socket/methodTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/socket/services.d.ts

@@ -0,0 +1,39 @@
+import { Socket } from './';
+import { CashOutTicketProps } from './methodTypes';
+import { ERequestIds } from 'binary/types';
+export declare class SocketServices {
+    parent: Socket;
+    constructor(parent: Socket);
+    getPlaceBetData(): {
+        requestId: number;
+        ticketId: number;
+        outputStake: number;
+        remainingStake: number;
+        expressStake: number;
+        cashoutChangeTypeSetting: number;
+        couponData: number;
+        device: number;
+        betBuilderBetsNumber: number;
+        betBuilderStake: number;
+        balanceType: number;
+        betBuilderOdd: number;
+        ordinarLength: number;
+        systemRang: number;
+        systemStake: number;
+        stake: number;
+        oddChangesType: number;
+        isTinder: number;
+        isAlternativeStakeAllowed: number;
+        byte: number;
+        ordinarBets: any[];
+        betBuilderBets: any;
+    };
+    getCashOutTicketInfo(props: CashOutTicketProps): {
+        requestId: ERequestIds;
+        ticketId: number;
+        outputStake: number;
+        remainingStake: number;
+        cashoutChangeTypeSetting: number;
+        typeMultiBet: number;
+    };
+}