@truelab/truelogic-plinko 0.0.1-0

package/dist/types/src/shared/api/prizeDrop/index.d.ts

@@ -0,0 +1,5 @@
+export { TApiPrizeDropCampaignsListError, TApiPrizeDropCampaignsListFake, TApiPrizeDropCampaignsListResponse, } from './campaignsList';
+export { TApiPrizeDropJoinCampaignError, TApiPrizeDropJoinCampaignFake, TApiPrizeDropJoinCampaignPayload, TApiPrizeDropJoinCampaignResponse, } from './joinCampaign';
+export { prizeDropFetch } from './lib';
+export { TApiPrizeDropSocketCredentials, TApiPrizeDropSocketCredentialsError, TApiPrizeDropSocketCredentialsFake, TApiPrizeDropSocketCredentialsResponse, } from './socketCredentials';
+export { TPrizeDropApiData } from './types';

package/dist/types/src/shared/api/prizeDrop/joinCampaign.d.ts

@@ -0,0 +1,16 @@
+export type TApiPrizeDropJoinCampaignPayload = {
+    campaignId: string;
+};
+export type TApiPrizeDropJoinCampaignResponse = {
+    joined: boolean;
+    message?: string;
+};
+export type TApiPrizeDropJoinCampaignFake = {
+    enabled: boolean;
+    delay: number;
+    countRetries: number;
+    response: string;
+    hasError: boolean;
+    error: string;
+};
+export type TApiPrizeDropJoinCampaignError = unknown;

package/dist/types/src/shared/api/prizeDrop/lib.d.ts

@@ -0,0 +1 @@
+export declare const prizeDropFetch: <TResponse>(method: "GET" | "POST", url: string, token: string, payload?: unknown, params?: Record<string, string>) => Promise<TResponse>;

package/dist/types/src/shared/api/prizeDrop/socketCredentials.d.ts

@@ -0,0 +1,16 @@
+export type TApiPrizeDropSocketCredentials = {
+    url: string;
+    token: string;
+    transports?: string[];
+};
+export type TApiPrizeDropSocketCredentialsResponse = {
+    credentials: TApiPrizeDropSocketCredentials;
+};
+export type TApiPrizeDropSocketCredentialsFake = {
+    enabled: boolean;
+    delay: number;
+    response: string;
+    hasError: boolean;
+    error: string;
+};
+export type TApiPrizeDropSocketCredentialsError = unknown;

package/dist/types/src/shared/api/prizeDrop/types.d.ts

@@ -0,0 +1,4 @@
+export type TPrizeDropApiData = {
+    url?: string;
+    token?: string;
+};

package/dist/types/src/shared/api/round/close/index.d.ts

@@ -0,0 +1 @@
+export type { TApiRoundCloseError, TApiRoundCloseFake, TApiRoundClosePayload, TApiRoundCloseResponse } from './types';

package/dist/types/src/shared/api/round/close/types.d.ts

@@ -0,0 +1,18 @@
+export type TApiRoundClosePayload = {
+    roundId: string;
+};
+export type TApiRoundCloseResponse = {
+    ok: boolean;
+};
+export type TApiRoundCloseError = {
+    name: string;
+    message: string;
+    code?: number;
+};
+export type TApiRoundCloseFake = {
+    enabled: boolean;
+    delay: number;
+    response: string;
+    hasError: boolean;
+    error: string;
+};

package/dist/types/src/shared/api/round/open/index.d.ts

@@ -0,0 +1,2 @@
+export type { TStake } from './types';
+export type { TApiRoundOpenError, TApiRoundOpenFake, TApiRoundOpenPayload, TApiRoundOpenResponse, TPromoTool, TResponseGS, } from './types';

package/dist/types/src/shared/api/round/open/types.d.ts

@@ -0,0 +1,54 @@
+export type TStake = {
+    amount: number;
+    name: string;
+    level?: number;
+    params?: string;
+};
+export type TResponseGS = {
+    response: string;
+    winCash: number;
+    winCoins?: number;
+    meta?: string;
+    choice?: number;
+    choices?: number[];
+    finished: boolean;
+};
+export type TPromoTool = {
+    balance: number;
+    count: number;
+    issued: number;
+    betIndex: number;
+    totalWon: number;
+    type: 'freerounds';
+    uuid: string;
+    addWinnings: boolean;
+    level?: number;
+};
+export type TApiRoundOpenPayload = {
+    stakes: TStake[];
+    test?: string;
+    pdCampaignId?: string;
+    betIndex: number;
+    balance?: number;
+    currency?: string;
+    meta?: unknown;
+};
+export type TApiRoundOpenResponse = {
+    roundId: string;
+    balance: number;
+    responseGS: TResponseGS;
+    promotools?: TPromoTool[];
+    meta?: unknown;
+};
+export type TApiRoundOpenError = {
+    name: string;
+    message: string;
+    code?: number;
+};
+export type TApiRoundOpenFake = {
+    enabled: boolean;
+    delay: number;
+    response: string;
+    hasError: boolean;
+    error: string;
+};

package/dist/types/src/shared/api/round/play/index.d.ts

@@ -0,0 +1 @@
+export type { TApiRoundPlayError, TApiRoundPlayFake, TApiRoundPlayPayload, TApiRoundPlayResponse } from './types';

package/dist/types/src/shared/api/round/play/types.d.ts

@@ -0,0 +1,19 @@
+import { TApiRoundOpenError, TApiRoundOpenFake, TApiRoundOpenResponse, TStake } from '../open';
+export type TApiRoundPlayPayload = {
+    roundId: string;
+    nextResponseIndex: number;
+    choice?: number;
+    test?: string;
+    betIndex?: number;
+    stakes?: TStake[];
+    balance?: number;
+    currency?: string;
+    meta?: unknown;
+};
+export type TApiRoundPlayResponse = Omit<TApiRoundOpenResponse, 'balance'> & {
+    meta?: unknown;
+};
+export type TApiRoundPlayError = TApiRoundOpenError;
+export type TApiRoundPlayFake = TApiRoundOpenFake & {
+    responseIndex: number;
+};

package/dist/types/src/shared/api/round/replay/index.d.ts

@@ -0,0 +1 @@
+export { TApiRoundReplayError, TApiRoundReplayFake, TApiRoundReplayPayload, TApiRoundReplayResponse } from './types';

package/dist/types/src/shared/api/round/replay/types.d.ts

@@ -0,0 +1,30 @@
+import { TLocalizationSettings } from "../../../localization";
+import { TComplianceSettings, TGameSettings, TRoundClient, TSessionSettings } from '../../config/types';
+export type TRoundClientReplay = TRoundClient & {
+    date: string;
+    replayUrl: string;
+};
+export type TApiRoundReplayPayload = {
+    lang: string;
+};
+export type TApiRoundReplayResponse = {
+    ok: boolean;
+    client: unknown;
+    localization: TLocalizationSettings;
+    game: TGameSettings;
+    session: Omit<TSessionSettings, 'restore' | 'balance'> & {
+        replay: TRoundClientReplay;
+    };
+    compliance: TComplianceSettings;
+};
+export type TApiRoundReplayError = {
+    name: string;
+    message: string;
+};
+export type TApiRoundReplayFake = {
+    enabled: boolean;
+    delay: number;
+    response: string;
+    hasError: boolean;
+    error: string;
+};

package/dist/types/src/shared/api/roundsHistory/index.d.ts

@@ -0,0 +1 @@
+export type { TApiRoundsHistoryFake, THistoryRoundData, TRoundsHistoryInterval, TRoundsHistoryPayload, TRoundsHistoryResponse, } from './types';

package/dist/types/src/shared/api/roundsHistory/types.d.ts

@@ -0,0 +1,21 @@
+export type THistoryRoundData = {
+    roundId: string;
+    date: string;
+    bet: number;
+    win: number;
+    xbet: number;
+    replayUrl: string;
+    balance: number;
+};
+export type TRoundsHistoryInterval = 'today' | 'yesterday' | 'lastWeek' | 'lastMonth';
+export type TRoundsHistoryPayload = object;
+export type TRoundsHistoryResponse = {
+    data: THistoryRoundData[];
+};
+export type TApiRoundsHistoryFake = {
+    enabled: boolean;
+    delay: number;
+    response: string;
+    hasError: boolean;
+    error: string;
+};

package/dist/types/src/shared/lib/classes/analyticsService.d.ts

@@ -0,0 +1,80 @@
+export declare enum EAnalyticsEvents {
+    modeReal = "mode_real",
+    modeDemo = "mode_demo",
+    win = "win",
+    lost = "lost",
+    replay = "replay",
+    pageview = "page_view",
+    leaveTheGame = "leave_the_game",
+    soundSetup = "sound_setup",
+    soundOn = "sound_on",
+    soundOff = "sound_off",
+    musicOn = "music_on",
+    musicOff = "music_off",
+    effectsOn = "effects_on",
+    effectsOff = "effects_off",
+    betsizeIncreased = "betsize_increased",
+    betsizeReduced = "betsize_reduced",
+    autoplayStarts = "autoplay_starts",
+    lossLimitSetup = "loss_limit_setup",
+    singleWinLimitSetup = "single_win_limit_setup",
+    stopUponBonusGameSetup = "stop_upon_bonus_game_setup",
+    modeSkip = "mode_skip",
+    realityCheck = "reality_check",
+    volumeSetup = "volume_setup",
+    volumeMusicSetup = "music_volume_setup",
+    volumeEffectsSetup = "effects_volume_setup",
+    fastPlay = "fast_play",
+    isPortrait = "portrait",
+    isLandscape = "landscape",
+    setUserId = "userIdSet",
+    setOperator = "operatorIdSet",
+    setBrand = "brandIdSet",
+    setSession = "setSession",
+    setCurrency = "currency"
+}
+export declare enum EAnalyticsEventsPrizeDrop {
+    setCampaignId = "campaignIdSet",
+    pdModalOpen = "pd_modal_open",
+    pdModalStartJoin = "pd_modal_startJoin",
+    pdModalJoinSuccess = "pd_modal_joinSuccess",
+    pdModalJoinError = "pd_modal_joinError",
+    pdModalEventsView = "pd_modal_events_view",
+    pdModalRulesView = "pd_modal_rules_view",
+    pdModalLiveOpen = "pd_modalLive_open",
+    pdModalLiveStartJoin = "pd_modalLive_startJoin",
+    pdModalLiveJoinSuccess = "pd_modalLive_joinSuccess",
+    pdModalLiveJoinError = "pd_modalLive_joinError",
+    pdModalLiveLater = "pd_modalLive_later",
+    pdModalSuccessOpen = "pd_modalSuccess_open",
+    pdModalSuccessClose = "pd_modalSuccess_close",
+    pdModalWinDropOpen = "pd_modalWinDrop_open",
+    pdModalWinDropClose = "pd_modalWinDrop_close",
+    pdModalEventCancelledOpen = "pd_modalEventCancelled_open",
+    pdModalEventCancelledClose = "pd_modalEventCancelled_close",
+    pdModalEventEndedOpen = "pd_modalEventEnded_open",
+    pdModalEventEndedClose = "pd_modalEventEnded_close",
+    pdModalJoinErrorOpen = "pd_modalJoinError_open",
+    pdModalJoinErrorStartRetry = "pd_modalJoinError_startRetry",
+    pdModalJoinErrorUnsuccessfulRetry = "pd_modalJoinError_unsuccessRetry",
+    pdModalJoinErrorSuccessRetry = "pd_modalJoinError_successRetry",
+    pdModalJoinErrorClose = "pd_modalJoinError_close"
+}
+export declare enum EAnalyticsCategories {
+    settings = "settings_changes",
+    ui = "ui_interaction",
+    gameplay = "gameplay_events",
+    mode = "game_mode",
+    config = "session_config"
+}
+export type TEventOptions = {
+    value?: number;
+    betType?: string;
+    currency?: string;
+};
+export declare class AnalyticsService {
+    available: boolean;
+    setSessionParameters(event: EAnalyticsEvents | EAnalyticsEventsPrizeDrop, name: string, value: string): void;
+    view(title: string, location: string, path: string): void;
+    event(event: EAnalyticsEvents | EAnalyticsEventsPrizeDrop, category: EAnalyticsCategories, options?: TEventOptions): void;
+}

package/dist/types/src/shared/lib/classes/cashService.d.ts

@@ -0,0 +1,51 @@
+export type TStakeData = {
+    amount: number;
+    level?: number;
+};
+export type TCashServiceInitConfig = {
+    currency: string;
+    currencyDecimals: number;
+    coinRatio: number;
+    lang: string;
+    stakeData: TStakeData;
+};
+export type TFormatCoinsOptions = {
+    showCurrency: boolean;
+};
+export type TFormatCashOptions = {
+    showCurrency?: boolean;
+    customCurrency?: string;
+    customDecimals?: number;
+};
+export declare class CashService {
+    currency: string;
+    currencyDecimals: number;
+    lang: string;
+    protected coinRatio: number;
+    protected coinValue: number;
+    protected formatter: Intl.NumberFormat;
+    init(config: TCashServiceInitConfig): void;
+    setStakeData({ amount, level }: TStakeData): void;
+    /**
+     * Format coins to cash without additional modifications
+     * @example
+     * truelogic.cashFormatter.coinsToCash(1000) // 250
+     */
+    coinsToCash(coins: number): number;
+    /**
+     * Format coins to cash with additional modifications
+     * @example
+     * truelogic.cashFormatter.formatCoins(1000, { showCurrency: true }) // '250 EUR'
+     */
+    formatCoins(coins: number, options?: TFormatCoinsOptions): string;
+    /**
+     * Format cash value with additional modifications
+     * @example
+     * Current currency is a 'EUR'
+     * truelogic.cashFormatter.formatCash(1250) // '1,250 EUR'
+     * truelogic.cashFormatter.formatCash(1250, { showCurrency: false }) // '1,250'
+     * truelogic.cashFormatter.formatCash(1250, { customCurrency: USD }) // '250 USD'
+     * truelogic.cashFormatter.formatCash(1250, { customCurrency: USD, customDecimals: 3 }) // '1,250.000 USD'
+     */
+    formatCash(cashValue: number, options?: TFormatCashOptions): string;
+}

package/dist/types/src/shared/lib/classes/cashService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/shared/lib/classes/emitter.d.ts

@@ -0,0 +1,11 @@
+type TVoidFunc = (...args: unknown[]) => void;
+type TEventsDeclaration = Record<string, TVoidFunc>;
+export declare abstract class Emitter<TEvents extends TEventsDeclaration> {
+    protected listeners: Map<keyof TEvents, TVoidFunc[]>;
+    protected listenersOneTime: Map<keyof TEvents, TVoidFunc[]>;
+    on<K extends keyof TEvents>(event: K, listener: TEvents[K]): this;
+    once<K extends keyof TEvents>(event: K, listener: TEvents[K]): this;
+    emit<K extends keyof TEvents>(event: K, ...args: Parameters<TEvents[K]>): void;
+    abstract log(event: unknown, ...args: unknown[]): void;
+}
+export {};

package/dist/types/src/shared/lib/classes/index.d.ts

@@ -0,0 +1,4 @@
+export { CashService } from './cashService';
+export { Emitter } from './emitter';
+export { Logger, TLoggerConfig } from './logger';
+export { UtilsService } from './utilsService';

package/dist/types/src/shared/lib/classes/integration/ErrorRelax.d.ts

@@ -0,0 +1,63 @@
+import * as Relax from '@rlx/feim';
+import { TApiRoundOpenError } from "../../../api/round/open";
+export type TErrorResults = {
+    showed: boolean;
+    error?: {
+        message: string;
+        title?: string;
+        button?: string;
+    };
+};
+export type TRoundOpenResponseErrorCustom = TApiRoundOpenError & {
+    custom?: Record<string, unknown> & {
+        details: Relax.IErrorMessage;
+    };
+};
+/**
+    "custom": {
+        "details": {
+            "errorCode": 559,
+            "errorDetails": {
+                "buttontext": "Custom error button text",
+                "message": "Custom error message",
+                "title": "Custom error title"
+            },
+            "errorMessage": "CUSTOM_ERROR"
+        }
+    }
+
+    Logic:
+    1. Try to show error message using `response.custom.details`
+    2. Try to show error message using `response.code`
+        (True Lab error code, see `_errors` and `_map` properties)
+        see https://docs.relax-gaming.com/p2p/portal/operator-integrations#error-information
+    3. Build own error object from `response.code` and `response.message`
+        see https://docs.relax-gaming.com/p2p/portal/p2p-wallet-api#error-codes-and-handling
+ */
+export default class ErrorRelax {
+    protected results: TErrorResults;
+    /**
+     * @see https://docs.relax-gaming.com/p2p/portal/operator-integrations#error-information
+     */
+    protected _errors: {
+        error: Relax.IErrorMessage;
+        codes: number[];
+    }[];
+    /**
+     * Map TL Code => RLX error
+     */
+    protected map: Map<number, Relax.IErrorMessage>;
+    /**
+     * Tries to show error message in operator's window using `Relax.showError()`.
+     * If message can't be shown then `callback()` will be triggered.
+     */
+    show(response: TRoundOpenResponseErrorCustom): Promise<TErrorResults>;
+    /**
+     * Triggers when operator can't show message
+     */
+    callback(message: Relax.IErrorMessage): Promise<void>;
+    /**
+     * Create own error object
+     */
+    getErrorObject(errorCode: number, errorMessage: string): Relax.IErrorMessage;
+}

package/dist/types/src/shared/lib/classes/integration/OperatorAbstractService.d.ts

@@ -0,0 +1,65 @@
+import { TErrorResults } from './ErrorRelax';
+export type TOperatorData = TLoaderData & TBetData & TBalanceData & TWinData & TRoundStartData & TRoundFinishData & TFeatureData & TSettingsData;
+export type TLoaderData = {
+    progress?: number;
+};
+export type TBetData = {
+    bet?: number;
+};
+export type TBalanceData = {
+    balance?: number;
+};
+export type TWinData = {
+    win?: number;
+};
+export type TRoundStartData = {
+    balance?: number;
+};
+export type TRoundFinishData = {
+    balance?: number;
+    win?: number;
+    bet?: number;
+};
+export type TFeatureData = {
+    type?: string;
+};
+export type TSettingsData = {
+    fastPlay?: boolean;
+    sounds?: boolean;
+};
+export type TOperatorServiceInitOptions = {
+    currency?: string;
+    casinoUrl?: string;
+};
+export type TOperatorError = TErrorResults;
+export default abstract class OperatorAbstractService {
+    protected casinoUrl?: string;
+    protected currency?: string;
+    onRulesShow: () => Promise<void>;
+    onPaytableShow: () => Promise<void>;
+    onSettingsUpdate: (data: TSettingsData) => Promise<void>;
+    onAutoplayStop: () => Promise<void>;
+    onFreeze: () => Promise<void>;
+    onUnfreeze: () => Promise<void>;
+    init(): Promise<void>;
+    initOptions(_options?: TOperatorServiceInitOptions): Promise<void>;
+    error(_response: unknown): Promise<TOperatorError>;
+    sendLoadStarted(): Promise<void>;
+    sendLoadProgress(_data: TLoaderData): Promise<void>;
+    sendLoadEnded(): Promise<void>;
+    sendBetUpdate(_data: TBetData): Promise<void>;
+    sendBalanceUpdate(_data: TBalanceData): Promise<void>;
+    sendWinUpdate(_data: TWinData): Promise<void>;
+    sendRoundStarted(_data: TRoundStartData): Promise<void>;
+    sendRoundFinished(_data: TRoundFinishData): Promise<void>;
+    sendFeatureStarted(_data: TFeatureData): Promise<void>;
+    sendFeatureFinished(_data: TFeatureData): Promise<void>;
+    sendAutoplayStarted(): Promise<void>;
+    sendAutoplayFinished(): Promise<void>;
+    sendDepositShow(): Promise<void>;
+    sendHistoryShow(): Promise<void>;
+    sendSettingsUpdate(_data: TSettingsData): Promise<void>;
+    sendGameExit(): Promise<void>;
+    sendFullscreenEnabled(): Promise<void>;
+    sendFullscreenDisabled(): Promise<void>;
+}

package/dist/types/src/shared/lib/classes/integration/OperatorBaseService.d.ts

@@ -0,0 +1,37 @@
+import { TErrorResults } from './ErrorRelax';
+import OperatorAbstractService, { TBalanceData, TRoundFinishData, TRoundStartData } from './OperatorAbstractService';
+export declare enum EOperatorBaseSendEvents {
+    gameStarted = "gameStarted",
+    gameCompleted = "gameCompleted",
+    changeBalance = "changeBalance",
+    leaveTheGame = "leaveTheGame",
+    fullscreenOn = "fullscreen-on",
+    fullscreenOff = "fullscreen-off",
+    modalRefill = "modalRefill"
+}
+export type TEventOptions = {
+    balance?: number;
+    stakeAmount?: number;
+    isSoundActive?: boolean;
+    progress?: number;
+    win?: number;
+};
+export declare class OperatorBaseService extends OperatorAbstractService {
+    init(): Promise<void>;
+    /**
+     * window.frames[0].postMessage({name: 'stopAutospins'}, '*')
+     * window.frames[0].postMessage({name: 'setAudio', data: true}, '*')
+     *
+     * For testing - use fex window.postMessage({name: 'onFreeze'}) in console
+     */
+    protected on(message: string, data: unknown): Promise<void>;
+    send(message: EOperatorBaseSendEvents, options?: TEventOptions): void;
+    error(): Promise<TErrorResults>;
+    sendBalanceUpdate(data: TBalanceData): Promise<void>;
+    sendRoundStarted(data: TRoundStartData): Promise<void>;
+    sendRoundFinished(data: TRoundFinishData): Promise<void>;
+    sendDepositShow(): Promise<void>;
+    sendGameExit(): Promise<void>;
+    sendFullscreenEnabled(): Promise<void>;
+    sendFullscreenDisabled(): Promise<void>;
+}

package/dist/types/src/shared/lib/classes/integration/OperatorGeneralService.d.ts

@@ -0,0 +1,44 @@
+import { TRoundOpenResponseErrorCustom } from './ErrorRelax';
+import OperatorAbstractService, { TOperatorData } from './OperatorAbstractService';
+export declare enum EEventOn {
+    onRulesShow = "onRulesShow",
+    onPaytableShow = "onPaytableShow",
+    onSettingsUpdate = "onSettingsUpdate",
+    onAutoplayStop = "onAutoplayStop",
+    onFreeze = "onFreeze",
+    onUnfreeze = "onUnfreeze"
+}
+export declare enum EEventSend {
+    sendLoadStarted = "sendLoadStarted",
+    sendLoadProgress = "sendLoadProgress",
+    sendLoadEnded = "sendLoadEnded",
+    sendBetUpdate = "sendBetUpdate",
+    sendBalanceUpdate = "sendBalanceUpdate",
+    sendWinUpdate = "sendWinUpdate",
+    sendRoundStarted = "sendRoundStarted",
+    sendRoundFinished = "sendRoundFinished",
+    sendFeatureStarted = "sendFeatureStarted",
+    sendFeatureFinished = "sendFeatureFinished",
+    sendAutoplayStarted = "sendAutoplayStarted",
+    sendAutoplayFinished = "sendAutoplayFinished",
+    sendDepositShow = "sendDepositShow",
+    sendHistoryShow = "sendHistoryShow",
+    sendSettingsUpdate = "sendSettingsUpdate",
+    sendGameExit = "sendGameExit",
+    sendFullscreenEnabled = "sendFullscreenEnabled",
+    sendFullscreenDisabled = "sendFullscreenDisabled"
+}
+export declare class OperatorGeneralService {
+    protected operatorServices: OperatorAbstractService[];
+    constructor(services: OperatorAbstractService[], events?: Record<EEventOn, (data?: unknown) => Promise<void>>);
+    initOptions(options?: {
+        currency?: string;
+        casinoUrl?: string;
+    }): void;
+    error(response: TRoundOpenResponseErrorCustom): {
+        message: string;
+        title?: string;
+        button?: string;
+    };
+    on(event: EEventSend, data?: TOperatorData): void;
+}

package/dist/types/src/shared/lib/classes/integration/OperatorRelaxService.d.ts

@@ -0,0 +1,28 @@
+import IP2PConfig from '@rlx/feim';
+import ErrorRelax, { TErrorResults, TRoundOpenResponseErrorCustom } from './ErrorRelax';
+import OperatorAbstractService, { TFeatureData, TOperatorServiceInitOptions, TRoundFinishData, TRoundStartData } from './OperatorAbstractService';
+export declare class OperatorRelaxService extends OperatorAbstractService {
+    protected _error: ErrorRelax;
+    init(): Promise<void>;
+    initOptions(options?: TOperatorServiceInitOptions): Promise<void>;
+    error(response: TRoundOpenResponseErrorCustom): Promise<TErrorResults>;
+    protected getConfig(): IP2PConfig.IModuleConfig;
+    protected getP2PConfig(): IP2PConfig.IP2PConfig;
+    sendGameLoadStarted(): void;
+    sendGameLoadProgress(progress: number): void;
+    sendGameLoadCompleted(): void;
+    sendRoundStarted(data: TRoundStartData): Promise<void>;
+    sendRoundFinished({ win }: TRoundFinishData): Promise<void>;
+    sendChangeBalance(stakeAmount: number): void;
+    sendStakeChanged(stakeAmount: number): void;
+    sendUpdateSettings(settings: {
+        sounds?: boolean;
+        fastPlay?: boolean;
+    }): void;
+    sendFeatureStarted(data: TFeatureData): Promise<void>;
+    sendFeatureFinished(data: TFeatureData): Promise<void>;
+    sendAutoPlayStarted(): void;
+    sendAutoPlayFinished(): void;
+    sendShowHistory(): void;
+    sendExitGame(): void;
+}

package/dist/types/src/shared/lib/classes/logger.d.ts

@@ -0,0 +1,21 @@
+type TLoggerOutput = {
+    data: unknown;
+    style?: string;
+};
+export type TLoggerConfig = {
+    events?: boolean;
+    errors?: boolean;
+};
+export declare class Logger {
+    config: TLoggerConfig;
+    log(partials: TLoggerOutput[]): void;
+    publicEvent(eventName: string, ...args: unknown[]): void;
+    gameEvent(eventName: string, ...args: unknown[]): void;
+    analyticsEvent(eventName: string, ...args: unknown[]): void;
+    integrationEvent(eventName: string, ...args: unknown[]): void;
+    operatorEvent(eventName: string, ...args: unknown[]): void;
+    socketEvent(eventName: string, ...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    hello(): void;
+}
+export {};

package/dist/types/src/shared/lib/classes/utilsService.d.ts

@@ -0,0 +1,14 @@
+export type TUtilsServiceInitConfig = {
+    defaultStakeAmount: number;
+    lang: string;
+};
+export declare class UtilsService {
+    protected defaultStakeAmount: number;
+    protected lang: string;
+    init(config: TUtilsServiceInitConfig): void;
+    setDefaultStakeAmount(amount: number): void;
+    setLang(lang: string): void;
+    getDefaultStakeAmount(): number;
+    getWinMultiplier(winCash: number): number;
+    formatPercent(percent: number, minimumFractionDigits?: number, maximumFractionDigits?: number): string;
+}

package/dist/types/src/shared/lib/constants/index.d.ts

@@ -0,0 +1 @@
+export { WIDGET_Z_INDEX } from './widgetZIndex';