react-memory-optimization 0.0.1

package/dist/lib/store/betting/entities/betslip/types.d.ts

@@ -0,0 +1,200 @@
+import { ResponseBet } from 'service/responseAdapter/types';
+export type BetSlipResponse = {
+    bets: ResponseBet[];
+    tickets: any[];
+};
+export type Bets = {
+    [betUidKey: string]: Bet;
+};
+export declare enum ECustomBetUid {
+    Express = "express",
+    System = "system",
+    BetBuilder = "betBuilder"
+}
+export type ExpressBet = {
+    status: EBetState;
+    maxToWin: number;
+    stake: string;
+    odd: string;
+    betUid: ECustomBetUid.Express;
+    betLength: number;
+};
+export type SystemBet = {
+    status: EBetState;
+    maxToWin: number;
+    stake: string;
+    odd: string;
+    betUid: ECustomBetUid.System;
+    betLength: number;
+    activeSystemRange: number;
+};
+export type Bet = {
+    eventUid: string;
+    lineUid: string;
+    outcomeId: number;
+    isPrematch: boolean;
+    stake: string;
+    betUid: string;
+    maxToWin: number;
+    status: EBetState;
+};
+export declare enum EBetType {
+    Ordinar = 1,
+    Express = 2,
+    System = 3,
+    BetBuilder = 4,
+    Tinder = 5
+}
+export declare enum EBetSlipName {
+    Unknown = 0,
+    Single = 1,
+    Double = 2,
+    Treble = 3,
+    Multi = 4
+}
+export declare enum EMaxStakeStatus {
+    NeedToGet = 0,
+    Loading = 1,
+    Success = 2,
+    Error = 3
+}
+export declare enum EBetState {
+    Unknown = 0,
+    Requested = 1,
+    Error = 2,
+    Accepted = 3,
+    EventOrLineNotFound = 4
+}
+export declare enum StatusCoupon {
+    Loading = 0,
+    Available = 1,
+    Sended = 2
+}
+export declare enum ESendMultiTicketType {
+    CashOut = 0,
+    BetSlipt = 4
+}
+export type CreateBetUidProps = {
+    eventUid: string;
+};
+export type SetMaxLimitProps = {
+    betKey: string;
+    maxToWin: number;
+};
+export type AddBetProps = {
+    lineUid: string;
+    eventUid: string;
+    isPrematch: boolean;
+    outcomeId: number;
+};
+export type RemoveBetProps = {
+    lineUid: string;
+    eventUid: string;
+    isPrematch: boolean;
+    outcomeId: number;
+} | {
+    betUid: string;
+};
+export type SetBetSlipStakeProps = {
+    betUid: string;
+    stake: string;
+};
+export type BetSlipObservableSettings = {
+    [key: string]: BetSlipObservableSetting;
+};
+export type UpdateIsSelectedOddProps = {
+    isSelectedOdd: true;
+    lineUid: string;
+    eventUid: string;
+    outcomeId: number;
+};
+type BetSlipObservableSetting = UpdateIsSelectedOddProps | {
+    isCounter: true;
+} | BetSlipObservableBetSetting | {
+    isBets: true;
+} | {
+    isBetSlipStatus: true;
+} | {
+    isShortBetSlipInfo: boolean;
+} | BetSlipObservableSettingMaxToWin | SpecialBetOdd | {
+    isBetSlipAmount: true;
+};
+export type SpecialBetOdd = {
+    isOdd: boolean;
+    systemOdd: boolean;
+    expressOdd: boolean;
+};
+export type BetSlipObservableBetSetting = {
+    isBet: true;
+    betUid: string;
+};
+export type BetSlipObservableSettingMaxToWin = {
+    isMaxToWin: boolean;
+    betUid: string;
+};
+export type SubscribeBettingBetSlipCounterCallbackProps = {
+    counterBets: number;
+};
+export type SubscribeBettingBetSlipCounterProps = {
+    uid: string;
+    callback: (counter: SubscribeBettingBetSlipCounterCallbackProps) => void;
+};
+export type ReturnIsSelectedOddState = {
+    isSelectedOddState: boolean;
+};
+export type SubscribeSelectedOdd = {
+    lineUid: string;
+    eventUid: string;
+    outcomeId: number;
+    uid: string;
+    callback: (s: ReturnIsSelectedOddState) => void;
+};
+export type SubscribeSpecialBetOdd = {
+    systemOdd: boolean;
+    expressOdd: boolean;
+    uid: string;
+    callback: (s: {
+        system?: number | string;
+        express?: number | string;
+    }) => void;
+};
+export declare enum EPlaceBetStatus {
+    Unknown = 0,
+    MaxLimitNotValid = 1,
+    StakeError = 2,
+    ReadyToBet = 3,
+    Sending = 4,
+    Success = 5,
+    Rejected = 6
+}
+export type ReturnSubscribeBetSlipShortInfoProps = {
+    oddInfo: {
+        expressOdd: string;
+        singleOddInfo: null | Bet;
+    };
+    betCounter: number;
+    betSlipName: string;
+};
+export type SubscribeBetSlipBaseProps = {
+    uid: string;
+    callback: (s: any) => void;
+    betUid?: string;
+};
+export type ReturnSubscribeBetSlipMaxToWinProps = {
+    maxToWin: number;
+};
+export type SubscribeBetSlipMaxToWinProps = {
+    uid: string;
+    betUid: string;
+    callback: (s: ReturnSubscribeBetSlipMaxToWinProps) => void;
+};
+export type ReturnBetSlipControllerTypes = {
+    addBet: (props: AddBetProps) => () => void;
+    removeBet: (props: RemoveBetProps) => () => void;
+    removeAllBets: () => void;
+    setStake: ({ betUid, stake }: SetBetSlipStakeProps) => void;
+    placeBet: () => void;
+    acceptErrors: () => void;
+    setSystemRang: (r: number) => void;
+};
+export {};

package/dist/lib/store/betting/entities/betslip/types.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EPlaceBetStatus = exports.ESendMultiTicketType = exports.StatusCoupon = exports.EBetState = exports.EMaxStakeStatus = exports.EBetSlipName = exports.EBetType = exports.ECustomBetUid = void 0;
+var ECustomBetUid;
+(function (ECustomBetUid) {
+    ECustomBetUid["Express"] = "express";
+    ECustomBetUid["System"] = "system";
+    ECustomBetUid["BetBuilder"] = "betBuilder";
+})(ECustomBetUid || (exports.ECustomBetUid = ECustomBetUid = {}));
+var EBetType;
+(function (EBetType) {
+    EBetType[EBetType["Ordinar"] = 1] = "Ordinar";
+    EBetType[EBetType["Express"] = 2] = "Express";
+    EBetType[EBetType["System"] = 3] = "System";
+    EBetType[EBetType["BetBuilder"] = 4] = "BetBuilder";
+    EBetType[EBetType["Tinder"] = 5] = "Tinder";
+})(EBetType || (exports.EBetType = EBetType = {}));
+var EBetSlipName;
+(function (EBetSlipName) {
+    EBetSlipName[EBetSlipName["Unknown"] = 0] = "Unknown";
+    EBetSlipName[EBetSlipName["Single"] = 1] = "Single";
+    EBetSlipName[EBetSlipName["Double"] = 2] = "Double";
+    EBetSlipName[EBetSlipName["Treble"] = 3] = "Treble";
+    EBetSlipName[EBetSlipName["Multi"] = 4] = "Multi";
+})(EBetSlipName || (exports.EBetSlipName = EBetSlipName = {}));
+var EMaxStakeStatus;
+(function (EMaxStakeStatus) {
+    EMaxStakeStatus[EMaxStakeStatus["NeedToGet"] = 0] = "NeedToGet";
+    EMaxStakeStatus[EMaxStakeStatus["Loading"] = 1] = "Loading";
+    EMaxStakeStatus[EMaxStakeStatus["Success"] = 2] = "Success";
+    EMaxStakeStatus[EMaxStakeStatus["Error"] = 3] = "Error";
+})(EMaxStakeStatus || (exports.EMaxStakeStatus = EMaxStakeStatus = {}));
+var EBetState;
+(function (EBetState) {
+    EBetState[EBetState["Unknown"] = 0] = "Unknown";
+    EBetState[EBetState["Requested"] = 1] = "Requested";
+    EBetState[EBetState["Error"] = 2] = "Error";
+    EBetState[EBetState["Accepted"] = 3] = "Accepted";
+    EBetState[EBetState["EventOrLineNotFound"] = 4] = "EventOrLineNotFound";
+})(EBetState || (exports.EBetState = EBetState = {}));
+var StatusCoupon;
+(function (StatusCoupon) {
+    StatusCoupon[StatusCoupon["Loading"] = 0] = "Loading";
+    StatusCoupon[StatusCoupon["Available"] = 1] = "Available";
+    StatusCoupon[StatusCoupon["Sended"] = 2] = "Sended";
+})(StatusCoupon || (exports.StatusCoupon = StatusCoupon = {}));
+var ESendMultiTicketType;
+(function (ESendMultiTicketType) {
+    ESendMultiTicketType[ESendMultiTicketType["CashOut"] = 0] = "CashOut";
+    ESendMultiTicketType[ESendMultiTicketType["BetSlipt"] = 4] = "BetSlipt";
+})(ESendMultiTicketType || (exports.ESendMultiTicketType = ESendMultiTicketType = {}));
+// bets
+var EPlaceBetStatus;
+(function (EPlaceBetStatus) {
+    EPlaceBetStatus[EPlaceBetStatus["Unknown"] = 0] = "Unknown";
+    EPlaceBetStatus[EPlaceBetStatus["MaxLimitNotValid"] = 1] = "MaxLimitNotValid";
+    EPlaceBetStatus[EPlaceBetStatus["StakeError"] = 2] = "StakeError";
+    EPlaceBetStatus[EPlaceBetStatus["ReadyToBet"] = 3] = "ReadyToBet";
+    EPlaceBetStatus[EPlaceBetStatus["Sending"] = 4] = "Sending";
+    EPlaceBetStatus[EPlaceBetStatus["Success"] = 5] = "Success";
+    EPlaceBetStatus[EPlaceBetStatus["Rejected"] = 6] = "Rejected";
+})(EPlaceBetStatus || (exports.EPlaceBetStatus = EPlaceBetStatus = {}));

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

@@ -0,0 +1,20 @@
+import { BettingServices } from '../../services';
+import { Observable } from '../../../../service/observable';
+import { CategorySports, ObservableSettingsType, SubscriberCategoriesProps, SubscriberCategoryProps, TCategories } from './types';
+export declare class Categories {
+    categories: TCategories;
+    sportCategories: CategorySports;
+    services: BettingServices;
+    categoriesObservable: Observable;
+    observableSettings: ObservableSettingsType;
+    isInitCategories: boolean;
+    constructor(services: BettingServices);
+    updateCategories(categories: TCategories): void;
+    setCategories(categories: TCategories): void;
+    sendUpdates(): void;
+    subscribeCategories(data: SubscriberCategoriesProps): void;
+    unsubscribeCategories(uid: string): void;
+    subscribeCategoryById(data: SubscriberCategoryProps): void;
+    unsubscribeCategoryById(uid: string): void;
+    reset(): void;
+}

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

@@ -0,0 +1,41 @@
+export type TCategories = {
+    [index: number]: Category;
+};
+export type Category = {
+    id: number;
+    isOutright: number;
+    name: string;
+    sortId: number;
+    sportId: number;
+    svg: string;
+};
+export type CategorySports = {
+    [sportId: number]: {
+        [categoryId: number]: number;
+    };
+};
+export type ObservableSettingsType = {
+    [key: string]: ObservableSettingType;
+};
+type ObservableSettingType = {
+    isPrematch: boolean;
+    sportId: number;
+    time?: number | null;
+} | {
+    categoryId: number;
+};
+export type SubscriberCategoriesProps = {
+    uid: string;
+    sportId: number;
+    time: number | null;
+    isPrematch: boolean;
+    callback: (info: {
+        id: number;
+    }[]) => void;
+};
+export type SubscriberCategoryProps = {
+    uid: string;
+    categoryId: number;
+    callback: (info: Category | null) => void;
+};
+export {};

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

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

package/dist/lib/store/betting/entities/events/index.d.ts

@@ -0,0 +1,41 @@
+import { BettingSettings } from 'store/betting/types';
+import { Observable } from '../../../../service/observable';
+import { BettingServices } from '../../services';
+import { LiveEvents } from './live';
+import { PrematchEvents } from './prematch';
+import { TopEvents } from './top';
+import { TopEventInfo } from './top/types';
+import { SettingEventsObservable, SubscribeBettingEventsByTournamentIdProps, SubscribeBettingTopEventsProps, SubscribeEventDetailsMarketTabs, SubscribeEventDetailsMarketsByGroupIdProps, SubscribeEventShortInfoProps, SubscribeLineEntitiesProps, SubscribeOdd, UpdateEvents } from './types';
+export declare class Events {
+    topEventObservable: Observable;
+    eventsObservable: Observable;
+    services: BettingServices;
+    liveEvents: LiveEvents;
+    prematchEvents: PrematchEvents;
+    topEvents: TopEvents;
+    _settings: BettingSettings | null;
+    settingEventsObservable: SettingEventsObservable;
+    constructor(services: BettingServices);
+    set settings(settings: BettingSettings);
+    get settings(): BettingSettings;
+    updateTopEvents(topEvents: TopEventInfo[]): void;
+    updateEvents({ prematchEvents, liveEvents }: UpdateEvents): void;
+    updateTopEventsSubscribers(): void;
+    getAvailableSportIds(isPrematch: boolean): string[];
+    sendUpdate(): void;
+    subscribeBettingTopEvents({ uid, callback }: SubscribeBettingTopEventsProps): void;
+    unsubscribeBettingTopEvents(uid: string): void;
+    subscribeEventsByTournamentId(props: SubscribeBettingEventsByTournamentIdProps): void;
+    unsubscribeEventsByTournamentId(uid: string): void;
+    subscribeOdd(props: SubscribeOdd): void;
+    unsubscribeOdd(uid: string, isPrematch: boolean): void;
+    subscribeEventShortInfo(props: SubscribeEventShortInfoProps): void;
+    unsubscribeEventShortInfo(uid: string, isPrematch: boolean): void;
+    subscribeEventDetailsMarketTabs(props: SubscribeEventDetailsMarketTabs): void;
+    unsubscribeEventDetailsMarketTabs(uid: string, isPrematch: boolean): void;
+    subscribeEventDetailsMarketsByGroupId(props: SubscribeEventDetailsMarketsByGroupIdProps): void;
+    unsubscribeEventDetailsMarketsByGroupId(uid: string, isPrematch: boolean): void;
+    subscribeLineEntities(props: SubscribeLineEntitiesProps): void;
+    unsubscribeLineEntities(uid: string, isPrematch: boolean): void;
+    reset(): void;
+}

package/dist/lib/store/betting/entities/events/live/index.d.ts

@@ -0,0 +1,56 @@
+import { Observable } from '../../../../../service/observable';
+import { BettingServices } from '../../../services';
+import { ObservableSettingsType, SubscribeEventDetailsMarketTabs, SubscribeEventDetailsMarketsByGroupIdProps, SubscribeEventEntitiesProps, SubscribeEventShortInfoProps, SubscribeLineEntitiesProps, SubscribeOdd } from '../types';
+import { CategoryLiveEvents, InitialLiveEvents, LiveEvent, LiveSports, OddObservableSettingsType, SubscribeLiveScoreProps, TournamentLiveEvents } from './types';
+export declare class LiveEvents {
+    eventsObservable: Observable;
+    oddObservable: Observable;
+    observableSettings: ObservableSettingsType;
+    oddObservableSettings: OddObservableSettingsType;
+    services: BettingServices;
+    events: InitialLiveEvents;
+    sports: LiveSports;
+    categories: CategoryLiveEvents;
+    tournaments: TournamentLiveEvents;
+    constructor(services: BettingServices);
+    updateEvents(events: LiveEvent[]): void;
+    handleUpdateEvent(event: LiveEvent): void;
+    disableLines(eventUid: string): void;
+    getAvailableSportIds(): string[];
+    getValidMarketId(marketId: number, eventUid: string): {
+        mainMarket: number;
+        isSpecial: boolean;
+        isShowMoreBtn: boolean;
+        outcomes: number[];
+        isFirstMarket?: undefined;
+    } | {
+        mainMarket: number;
+        isSpecial: boolean;
+        isShowMoreBtn: boolean;
+        outcomes: number[];
+        isFirstMarket: boolean;
+    };
+    private sendEventUpdate;
+    private updateLinesByMarketId;
+    private updateEventScore;
+    private sendLineUpdate;
+    private sendLinesByComboMarketUpdates;
+    private sendLineCOunterUpdate;
+    sendUpdates(): void;
+    sendOddUpdate(): void;
+    subscribeEventEntities(props: SubscribeEventEntitiesProps): void;
+    unsubscribeEventEntities(uid: string): void;
+    subscribeOdd(props: SubscribeOdd): void;
+    unsubscribeOdd(uid: string): void;
+    subscribeEventScore(props: SubscribeLiveScoreProps): void;
+    unsubscribeEventScore(uid: string): void;
+    subscribeEventShortInfo(props: SubscribeEventShortInfoProps): void;
+    unsubscribeEventShortInfo(uid: string): void;
+    subscribeEventDetailsMarketTabs(props: SubscribeEventDetailsMarketTabs): void;
+    unsubscribeEventDetailsMarketTabs(uid: string): void;
+    subscribeEventDetailsMarketsByGroupId(props: SubscribeEventDetailsMarketsByGroupIdProps): void;
+    unsubscribeEventDetailsMarketsByGroupId(uid: string): void;
+    subscribeLineEntities(props: SubscribeLineEntitiesProps): void;
+    unsubscribeLineEntities(uid: string): void;
+    reset(): void;
+}

package/dist/lib/store/betting/entities/events/live/types.d.ts

@@ -0,0 +1,116 @@
+import { ESports } from '../../sports/types';
+import { EventLine, EventProviderId, EStatusEvent } from '../types';
+export type LiveEvent = {
+    awayCorners: number;
+    awayId: number;
+    awayMainScore: number;
+    awayName: string;
+    awayRed: number;
+    awayRedCards: number;
+    awayYellow: number;
+    blockedStatus: number;
+    categoryId: number;
+    counterLines: number;
+    gbId: number;
+    homeCorners: number;
+    homeId: number;
+    homeMainScore: number;
+    homeName: string;
+    homeRedCards: number;
+    homeYellow: number;
+    lineTypeRadar: number;
+    matchStatus: string;
+    matchStatusId: number;
+    matchTime: string;
+    objectId: number;
+    overtime: number;
+    period: number;
+    position: number;
+    providerEvent: EventProviderId;
+    radarOriginalId: number;
+    remainingTime: string;
+    remainingTimeInPeriod: string;
+    scores: string;
+    sportId: number;
+    status: EStatusEvent;
+    stopPageTime: string;
+    stopPageTimeAnnounced: string;
+    stopTime: boolean;
+    timeStart: number;
+    tournamentId: number;
+    tournamentTypeRadar: number;
+    tvChanel: string;
+    uid: string;
+    videoId: string;
+    videoProviderId: number;
+    lines: {
+        [lineUid: string]: EventLine;
+    };
+    linesByMarketId: {
+        [marketId: number]: EventLine[];
+    };
+};
+export type InitialLiveEvents = {
+    [uid: string]: LiveEvent;
+};
+export type LiveSports = {
+    [sportId: number]: {
+        [eventUid: string]: string;
+    };
+};
+export type CategoryLiveEvents = {
+    [sportId: number]: {
+        [eventUid: string]: string;
+    };
+};
+export type TournamentLiveEvents = {
+    [sportId: number]: {
+        [eventUid: string]: string;
+    };
+};
+export type LiveEventsShortEventView = {
+    homeName: string;
+    awayName: string;
+    lines: number;
+    tournamentId: number;
+    categoryId: number;
+    uid: string;
+    id: string;
+    currentTime: number;
+    sportId: number;
+};
+export type OddObservableSettingsType = {
+    [key: string]: OddObservableSettingType;
+};
+type OddObservableSettingType = {
+    outcomeId: number;
+    lineUid: string;
+    eventUid: string;
+};
+export type ScoreReturnTypes = {
+    main: {
+        home: number;
+        away: number;
+        activeTeam: 'home' | 'away' | 'unknown';
+    };
+    times: ScoreTime[];
+    additional: any;
+    compareKey?: string;
+};
+export type ScoreTime = {
+    home: string;
+    away: string;
+    time: number;
+};
+export type ScoreMain = {
+    home: number;
+    away: number;
+    activeTeam: 'home' | 'away' | 'unknown';
+};
+export type SubscribeLiveScoreProps = {
+    uid: string;
+    eventUid: string;
+    sportId: ESports;
+    callback: (score: ScoreReturnTypes) => void;
+};
+export {};

package/dist/lib/store/betting/entities/events/live/types.js

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

package/dist/lib/store/betting/entities/events/prematch/index.d.ts

@@ -0,0 +1,44 @@
+import { BettingServices } from '../../../services';
+import { Observable } from '../../../../../service/observable';
+import { InitialPrematchEvents, CategoryPrematchEvents, PrematchSports, TournamentPrematchEvents, PrematchEvent, OddObservableSettingsType } from './types';
+import { ObservableSettingsType, SubscribeEventDetailsMarketTabs, SubscribeEventDetailsMarketsByGroupIdProps, SubscribeEventEntitiesProps, SubscribeEventShortInfoProps, SubscribeLineEntitiesProps, SubscribeOdd } from '../types';
+export declare class PrematchEvents {
+    eventsObservable: Observable;
+    oddObservable: Observable;
+    services: BettingServices;
+    events: InitialPrematchEvents;
+    sports: PrematchSports;
+    categories: CategoryPrematchEvents;
+    tournaments: TournamentPrematchEvents;
+    observableSettings: ObservableSettingsType;
+    oddObservableSettings: OddObservableSettingsType;
+    isFirstDataPack: boolean;
+    extraLines: {
+        [eventUid: string]: true;
+    };
+    constructor(services: BettingServices);
+    updatePrematchEvents(events: PrematchEvent[]): void;
+    handleUpdateEvent(event: PrematchEvent): void;
+    updateEvents(events: PrematchEvent[]): void;
+    getAvailableSportIds(): string[];
+    private sendEventUpdate;
+    private sendLinesByMarketId;
+    private sendLineUpdate;
+    private sendLinesByComboMarketUpdates;
+    private sendLineCOunterUpdate;
+    sendUpdates(): void;
+    sendOddUpdate(): void;
+    subscribeEventEntities(props: SubscribeEventEntitiesProps): void;
+    unsubscribeEventEntities(uid: string): void;
+    subscribeOdd(props: SubscribeOdd): void;
+    unsubscribeOdd(uid: string): void;
+    subscribeEventShortInfo(props: SubscribeEventShortInfoProps): void;
+    unsubscribeEventShortInfo(uid: string): void;
+    subscribeEventDetailsMarketTabs(props: SubscribeEventDetailsMarketTabs): void;
+    unsubscribeEventDetailsMarketTabs(uid: string): void;
+    subscribeEventDetailsMarketsByGroupId(props: SubscribeEventDetailsMarketsByGroupIdProps): void;
+    unsubscribeEventDetailsMarketsByGroupId(uid: string): void;
+    subscribeLineEntities(props: SubscribeLineEntitiesProps): void;
+    unsubscribeLineEntities(uid: string): void;
+    reset(): void;
+}

package/dist/lib/store/betting/entities/events/prematch/types.d.ts

@@ -0,0 +1,66 @@
+import { EventLine, EventProviderId, EStatusEvent } from '../types';
+export type PrematchEvent = {
+    objectId: number;
+    uid: string;
+    awayId: number;
+    awayName: string;
+    blockedStatus: number;
+    willBeLive: number;
+    categoryId: number;
+    gbId: number;
+    homeId: number;
+    homeName: string;
+    lineTypeRadar: number;
+    counterLines: number;
+    radarOriginalId: number;
+    sportId: number;
+    status: EStatusEvent;
+    timeStart: number;
+    tournamentId: number;
+    tournamentTypeRadar: number;
+    lines: {
+        [uid: string]: EventLine;
+    };
+    linesByMarketId: {
+        [marketId: number]: EventLine[];
+    };
+    providerEvent: EventProviderId;
+};
+export type InitialPrematchEvents = {
+    [uid: string]: PrematchEvent;
+};
+export type PrematchSports = {
+    [sportId: number]: {
+        [eventUid: string]: string;
+    };
+};
+export type CategoryPrematchEvents = {
+    [categoryId: number]: {
+        [eventUid: string]: string;
+    };
+};
+export type TournamentPrematchEvents = {
+    [tournamentId: number]: {
+        [eventUid: string]: string;
+    };
+};
+export type PrematchShortEventView = {
+    homeName: string;
+    awayName: string;
+    lines: number;
+    tournamentId: number;
+    categoryId: number;
+    uid: string;
+    id: string;
+    timeStart: number;
+    sportId: number;
+};
+export type OddObservableSettingsType = {
+    [key: string]: OddObservableSettingType;
+};
+type OddObservableSettingType = {
+    outcomeId: number;
+    lineUid: string;
+    eventUid: string;
+};
+export {};

package/dist/lib/store/betting/entities/events/prematch/types.js

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

package/dist/lib/store/betting/entities/events/top/index.d.ts

@@ -0,0 +1,7 @@
+import { TopEventInfo } from './types';
+export declare class TopEvents {
+    topEvents: TopEventInfo[];
+    constructor();
+    updateTopEvents(result: TopEventInfo[]): void;
+    reset(): void;
+}

package/dist/lib/store/betting/entities/events/top/types.d.ts

@@ -0,0 +1,5 @@
+export type TopEventInfo = {
+    gbEventId: number;
+    isLive: boolean;
+    position: number;
+};

package/dist/lib/store/betting/entities/events/top/types.js

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