@truelab/truelogic-plinko 0.0.1-0

package/dist/types/src/entities/play/model/apiRoundCloseSlice.d.ts

@@ -0,0 +1,15 @@
+import { TApiRoundCloseError, TApiRoundCloseFake, TApiRoundClosePayload, TApiRoundCloseResponse } from "../../../shared/api/round/close";
+type TApiRoundCloseState = {
+    data: TApiRoundCloseResponse;
+    isPending: boolean;
+    error: {
+        name: string;
+        message: string;
+    };
+    fake: TApiRoundCloseFake;
+};
+export declare const fetchApiRoundClose: import("@reduxjs/toolkit").AsyncThunk<TApiRoundCloseResponse, TApiRoundClosePayload, {
+    rejectValue: TApiRoundCloseError;
+}>, setApiRoundCloseFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiRoundCloseFake, "apiRoundClose/setApiRoundCloseFake">;
+export declare const apiRoundCloseReducer: import("redux").Reducer<TApiRoundCloseState>;
+export {};

package/dist/types/src/entities/play/model/apiRoundOpenSlice.d.ts

@@ -0,0 +1,15 @@
+import { TApiRoundOpenError, TApiRoundOpenFake, TApiRoundOpenPayload, TApiRoundOpenResponse } from "../../../shared/api/round/open";
+type TApiRoundOpenState = {
+    data: TApiRoundOpenResponse;
+    isPending: boolean;
+    error: {
+        name: string;
+        message: string;
+    };
+    fake: TApiRoundOpenFake;
+};
+export declare const fetchApiRoundOpen: import("@reduxjs/toolkit").AsyncThunk<TApiRoundOpenResponse, TApiRoundOpenPayload, {
+    rejectValue: TApiRoundOpenError;
+}>, setApiRoundOpenFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiRoundOpenFake, "apiRoundOpen/setApiRoundOpenFake">;
+export declare const apiRoundOpenReducer: import("redux").Reducer<TApiRoundOpenState>;
+export {};

package/dist/types/src/entities/play/model/apiRoundPlaySlice.d.ts

@@ -0,0 +1,15 @@
+import { TApiRoundPlayError, TApiRoundPlayFake, TApiRoundPlayPayload, TApiRoundPlayResponse } from "../../../shared/api/round/play";
+type TApiRoundPlayState = {
+    data: TApiRoundPlayResponse;
+    isPending: boolean;
+    error: {
+        name: string;
+        message: string;
+    };
+    fake: TApiRoundPlayFake;
+};
+export declare const fetchApiRoundPlay: import("@reduxjs/toolkit").AsyncThunk<TApiRoundPlayResponse, TApiRoundPlayPayload, {
+    rejectValue: TApiRoundPlayError;
+}>, setApiRoundPlayFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiRoundPlayFake, "apiRoundPlay/setApiRoundPlayFake">, setApiRoundPlayFakeNextResponse: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"apiRoundPlay/setApiRoundPlayFakeNextResponse">;
+export declare const apiRoundPlayReducer: import("redux").Reducer<TApiRoundPlayState>;
+export {};

package/dist/types/src/entities/play/model/playSlice.d.ts

@@ -0,0 +1,6 @@
+type TPlayState = {
+    isActive: boolean;
+};
+export declare const setPlayStarted: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"play/setPlayStarted">, setPlayEnded: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"play/setPlayEnded">;
+export declare const playReducer: import("redux").Reducer<TPlayState>;
+export {};

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

@@ -0,0 +1,6 @@
+export type TSpinEndedOptions = {
+    isBonusReached: boolean;
+};
+export type TStepEndedOptions = {
+    hasMaxWin: boolean;
+};

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

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

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

@@ -0,0 +1,59 @@
+import { TApiPrizeDropCampaignsListError, TApiPrizeDropCampaignsListFake, TApiPrizeDropCampaignsListResponse, TApiPrizeDropJoinCampaignError, TApiPrizeDropJoinCampaignFake, TApiPrizeDropJoinCampaignPayload, TApiPrizeDropJoinCampaignResponse, TApiPrizeDropSocketCredentialsError, TApiPrizeDropSocketCredentialsFake, TApiPrizeDropSocketCredentialsResponse, TPrizeDropApiData } from "../../../shared/api/prizeDrop";
+import { TAppThunkAction } from "../../../shared/lib/store";
+import { TPrizeDropCampaign, TPrizeDropWinItem } from "../../../shared/model/prizeDrop";
+import { TPrizeDropSocketEventPayloadCampaignUpdated, TPrizeDropSocketEventPayloadDrop, TSocketPrizeDropFake } from "../../../shared/sockets";
+export type TPrizeDropMode = 'live' | 'upcoming' | 'ended';
+type TApiData<D, F> = {
+    data: D;
+    isPending: boolean;
+    error: {
+        name: string;
+        message: string;
+    };
+    fake: F;
+};
+type TPrizeDropsState = {
+    campaign?: TPrizeDropCampaign;
+    winDropItem?: TPrizeDropWinItem;
+    apiCampaignsList: TApiData<TApiPrizeDropCampaignsListResponse, TApiPrizeDropCampaignsListFake>;
+    apiJoinCampaign: TApiData<TApiPrizeDropJoinCampaignResponse, TApiPrizeDropJoinCampaignFake>;
+    apiSocketCredentials: TApiData<TApiPrizeDropSocketCredentialsResponse, TApiPrizeDropSocketCredentialsFake>;
+    socketConnection?: TApiData<null, TSocketPrizeDropFake> & {
+        isSuccess: boolean;
+    };
+    restData?: TPrizeDropApiData;
+    hasDefferedModal?: boolean;
+    defferedCampaign?: TPrizeDropSocketEventPayloadCampaignUpdated;
+};
+export declare const setPrizeDropCampaign: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TPrizeDropCampaign, "prizeDrop/setPrizeDropCampaign">, setPrizeDropSocketEventCampaignUpdated: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TPrizeDropSocketEventPayloadCampaignUpdated, "prizeDrop/setPrizeDropSocketEventCampaignUpdated">, setPrizeDropSocketEventDrop: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TPrizeDropSocketEventPayloadDrop, "prizeDrop/setPrizeDropSocketEventDrop">, setPrizeDropWinItem: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TPrizeDropWinItem, "prizeDrop/setPrizeDropWinItem">, clearPrizeDropWinItem: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"prizeDrop/clearPrizeDropWinItem">, setApiPrizeDropCampaignsListFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiPrizeDropCampaignsListFake, "prizeDrop/setApiPrizeDropCampaignsListFake">, setApiPrizeDropJoinCampaignFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiPrizeDropJoinCampaignFake, "prizeDrop/setApiPrizeDropJoinCampaignFake">, setApiPrizeDropSocketCredentialsFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiPrizeDropSocketCredentialsFake, "prizeDrop/setApiPrizeDropSocketCredentialsFake">, setPrizeDropRestData: import("@reduxjs/toolkit").ActionCreatorWithNonInferrablePayload<"prizeDrop/setPrizeDropRestData">, fetchApiPrizeDropCampaignsList: import("@reduxjs/toolkit").AsyncThunk<TApiPrizeDropCampaignsListResponse, void, {
+    rejectValue: TApiPrizeDropCampaignsListError;
+}>, fetchApiPrizeDropJoinCampaign: import("@reduxjs/toolkit").AsyncThunk<TApiPrizeDropJoinCampaignResponse, TApiPrizeDropJoinCampaignPayload, {
+    rejectValue: TApiPrizeDropJoinCampaignError;
+}>, fetchApiPrizeDropSocketCredentials: import("@reduxjs/toolkit").AsyncThunk<TApiPrizeDropSocketCredentialsResponse, void, {
+    rejectValue: TApiPrizeDropSocketCredentialsError;
+}>, connectPrizeDropSocketService: import("@reduxjs/toolkit").AsyncThunk<Promise<void>, void, {
+    rejectValue: unknown;
+}>, setPrizeDropSocketFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TSocketPrizeDropFake, "prizeDrop/setPrizeDropSocketFake">, setPrizeDropDefferedModal: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "prizeDrop/setPrizeDropDefferedModal">, joinPrizeDropCampaign: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    campaignId: string;
+}, "prizeDrop/joinPrizeDropCampaign">, setPrizeDropDefferedCampaign: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TPrizeDropSocketEventPayloadCampaignUpdated, "prizeDrop/setPrizeDropDefferedCampaign">, clearPrizeDropDefferedCampaign: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"prizeDrop/clearPrizeDropDefferedCampaign">, clearPrizeDropJoinCampaignError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"prizeDrop/clearPrizeDropJoinCampaignError">;
+export declare const isPrizeDropActive: import("reselect").Selector<{
+    prizeDrop: TPrizeDropsState;
+}, boolean, []> & {
+    unwrapped: (state: TPrizeDropsState) => boolean;
+}, getPrizeDropMode: import("reselect").Selector<{
+    prizeDrop: TPrizeDropsState;
+}, TPrizeDropMode, []> & {
+    unwrapped: (state: TPrizeDropsState) => TPrizeDropMode;
+}, isPrizeDropJoined: import("reselect").Selector<{
+    prizeDrop: TPrizeDropsState;
+}, boolean, []> & {
+    unwrapped: (state: TPrizeDropsState) => boolean;
+}, getPrizeDropMaxPrize: import("reselect").Selector<{
+    prizeDrop: TPrizeDropsState;
+}, import("../../../shared/model/prizeDrop").TPrizeDropCampaignPrize, []> & {
+    unwrapped: (state: TPrizeDropsState) => import("../../../shared/model/prizeDrop").TPrizeDropCampaignPrize;
+};
+export declare const prizeDropReducer: import("redux").Reducer<TPrizeDropsState>;
+export declare const handlePrizeDropSocketEventCampaignUpdated: TAppThunkAction;
+export declare const handlePrizeDropSocketEventDrop: TAppThunkAction;
+export {};

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

@@ -0,0 +1,6 @@
+type TProps = {
+    disabled?: boolean;
+    className?: string;
+};
+export declare const PanelPrizeDrop: ({ disabled, className }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+type TProps = {
+    betStatus: boolean | null;
+};
+export declare const PrizeDropEventsBetStatus: ({ betStatus }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+import { TPrizeDropMode } from '../../../model/prizeDropSlice';
+type TProps = {
+    prizeDropMode: TPrizeDropMode;
+    betStatus: boolean | null;
+    isJoined: boolean;
+};
+export declare const PrizeDropEventsHeader: ({ prizeDropMode, betStatus, isJoined }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+type TProps = {
+    minimumBet: number;
+    className?: string;
+};
+export declare const PrizeDropEventsMinBet: ({ minimumBet, className }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,5 @@
+type TProps = {
+    className?: string;
+};
+export declare const PrizeDropEventsPrizes: ({ className }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+type TProps = {
+    prizesLeftCount: number;
+    winnersCount: number;
+};
+export declare const PrizeDropEventsStats: ({ prizesLeftCount, winnersCount }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,21 @@
+import 'dayjs/locale/de';
+import 'dayjs/locale/ru';
+import 'dayjs/locale/es';
+import 'dayjs/locale/fi';
+import 'dayjs/locale/fr';
+import 'dayjs/locale/hr';
+import 'dayjs/locale/nl';
+import 'dayjs/locale/nb';
+import 'dayjs/locale/pt';
+import 'dayjs/locale/sr';
+import 'dayjs/locale/sv';
+import 'dayjs/locale/th';
+import 'dayjs/locale/tr';
+import 'dayjs/locale/zh';
+type TProps = {
+    dateStart: string;
+    dateEnd: string;
+    className?: string;
+};
+export declare const PrizeDropInterval: ({ dateStart, dateEnd, className }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { FC } from 'react';
+export type TTabId = 'events' | 'rules';
+export type TTabsHeaderConfig = {
+    id: TTabId;
+    title: string;
+}[];
+type TProps = {
+    activeTab: TTabId;
+    setActiveTab: (tabId: TTabId) => void;
+    config: TTabsHeaderConfig;
+};
+export declare const TabsHeader: FC<TProps>;
+export {};

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

@@ -0,0 +1,4 @@
+export { useRealityCheck } from './lib/hook/useRealityCheck';
+export { getRealityCheckIsReadyForSave, realityCheckReducer, refreshRealityCheck, resetRealityCheckValues, saveRealityCheck, setReailtyCheckActiveReminder, setReailtyCheckDeferred, setRealityCheckIsActive, setRealityCheckPaused, setRealityCheckReminderTime, setRealityCheckRepeatReminderTime, } from './model/realityCheckSlice';
+export { RealityCheckSwitcher } from './ui/RealityCheckSwitcher/RealityCheckSwitcher';
+export { RealityCheckTime } from './ui/RealityCheckTime/RealityCheckTime';

package/dist/types/src/entities/realityCheck/lib/hook/useRealityCheck.d.ts

@@ -0,0 +1 @@
+export declare const useRealityCheck: () => void;

package/dist/types/src/entities/realityCheck/model/realityCheckSlice.d.ts

@@ -0,0 +1,40 @@
+type TRealityCheckTime = {
+    value: number;
+    customValue: number;
+};
+type TRealityCheckState = {
+    isActive: boolean;
+    isActiveToggle: boolean;
+    isActiveReminder: boolean;
+    isPausedActive: boolean;
+    timeValues: number[];
+    repeatTimeValues: number[];
+    hasDeferred: boolean;
+    startRepeatReminderTime: number;
+    startReminderTime: number;
+    delayTime: number;
+    reminderTime?: {
+        new?: TRealityCheckTime;
+        current: TRealityCheckTime;
+    };
+    repeatReminderTime?: {
+        new?: TRealityCheckTime;
+        current?: TRealityCheckTime;
+    };
+};
+export declare const setRealityCheckActiveToggle: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "realityCheck/setRealityCheckActiveToggle">, saveRealityCheck: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    enabled: boolean;
+    dateNow: number;
+}, "realityCheck/saveRealityCheck">, setRealityCheckReminderTime: import("@reduxjs/toolkit").ActionCreatorWithNonInferrablePayload<"realityCheck/setRealityCheckReminderTime">, setRealityCheckRepeatReminderTime: import("@reduxjs/toolkit").ActionCreatorWithNonInferrablePayload<"realityCheck/setRealityCheckRepeatReminderTime">, refreshRealityCheck: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    dateNow: number;
+}, "realityCheck/refreshRealityCheck">, setReailtyCheckDeferred: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "realityCheck/setReailtyCheckDeferred">, setRealityCheckIsActive: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "realityCheck/setRealityCheckIsActive">, resetRealityCheckValues: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"realityCheck/resetRealityCheckValues">, setRealityCheckPaused: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    enabled: boolean;
+    dateNow: number;
+}, "realityCheck/setRealityCheckPaused">, setReailtyCheckActiveReminder: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "realityCheck/setReailtyCheckActiveReminder">;
+export declare const getRealityCheckIsReadyForSave: import("reselect").Selector<{
+    realityCheck: TRealityCheckState;
+}, number, []> & {
+    unwrapped: (state: TRealityCheckState) => number;
+};
+export declare const realityCheckReducer: import("redux").Reducer<TRealityCheckState>;
+export {};

package/dist/types/src/entities/realityCheck/ui/RealityCheckSwitcher/RealityCheckSwitcher.d.ts

@@ -0,0 +1,7 @@
+type TRealityCheckSwitcherProps = {
+    isActive: boolean;
+    onClick: () => void;
+    className?: string;
+};
+export declare const RealityCheckSwitcher: ({ isActive, onClick, className }: TRealityCheckSwitcherProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/entities/realityCheck/ui/RealityCheckTime/RealityCheckTime.d.ts

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

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

@@ -0,0 +1,2 @@
+export { TWin } from './model/roundSlice';
+export { addRoundResponseGS, clearRoundWin, initRound, resetRoundCurrent, roundReducer, setRoundChoice, setRoundHasMaxWin, setRoundIsRestore, setRoundMeta, setRoundNextResponseGS, setRoundWasRestore, setRoundWin, } from './model/roundSlice';

package/dist/types/src/entities/round/model/roundSlice.d.ts

@@ -0,0 +1,33 @@
+import { TResponseGS } from "../../../shared/api/round/open/types";
+export type TWin = {
+    winCash: number;
+    mode?: 'single' | 'total';
+    animate?: boolean;
+};
+type TRoundState = {
+    roundId: string;
+    meta?: unknown;
+    responsesGS: TResponseGS[];
+    isRestore: boolean;
+    wasRestore: boolean;
+    hasMaxWin: boolean;
+    current: {
+        responseGS: TResponseGS;
+        responseGSIndex: number;
+        isFinished: boolean;
+        win: TWin;
+        choice?: number;
+    };
+    final: {
+        balance: number;
+        winCash: number;
+    };
+};
+export declare const initRound: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    roundId: string;
+    responsesGS: TResponseGS[];
+    balance: number;
+    meta?: unknown;
+}, "round/initRound">, setRoundNextResponseGS: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"round/setRoundNextResponseGS">, clearRoundWin: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"round/clearRoundWin">, setRoundChoice: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "round/setRoundChoice">, setRoundIsRestore: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "round/setRoundIsRestore">, setRoundWasRestore: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "round/setRoundWasRestore">, setRoundWin: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TWin, "round/setRoundWin">, setRoundHasMaxWin: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "round/setRoundHasMaxWin">, addRoundResponseGS: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TResponseGS, "round/addRoundResponseGS">, resetRoundCurrent: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"round/resetRoundCurrent">, setRoundMeta: import("@reduxjs/toolkit").ActionCreatorWithNonInferrablePayload<"round/setRoundMeta">;
+export declare const roundReducer: import("redux").Reducer<TRoundState>;
+export {};

package/dist/types/src/entities/roundsHistory/api/apiRoundsHistory.d.ts

@@ -0,0 +1,3 @@
+import { TRoundsHistoryPayload } from "../../../shared/api/roundsHistory";
+import { TAppThunkAction } from "../../../shared/lib/store";
+export declare const apiRoundsHistory: TAppThunkAction<TRoundsHistoryPayload>;

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

@@ -0,0 +1,5 @@
+export { apiRoundsHistory } from './api/apiRoundsHistory';
+export { clearRoundsHistory, roundsHistoryReducer, setRoundsHistoryFake, setRoundsHistoryReplayRoundData, setRoundsHistoryReplayStatus, setRoundsHistoryRounds, setRoundsHistorySelectedRoundUUID, } from './model/roundsHistorySlice';
+export { RoundsHistoryNothingHere } from './ui/RoundsHistoryNothingHere';
+export { RoundsHistoryPeriodSelector } from './ui/RoundsHistoryPeriodSelector';
+export { RoundsHistoryTable } from './ui/RoundsHistoryTable';

package/dist/types/src/entities/roundsHistory/model/roundsHistorySlice.d.ts

@@ -0,0 +1,21 @@
+import { TApiRoundsHistoryFake, THistoryRoundData, TRoundsHistoryResponse } from "../../../shared/api/roundsHistory";
+type TReplayStatus = 'start' | 'end';
+type TReplayRoundData = Pick<THistoryRoundData, 'date' | 'replayUrl' | 'bet' | 'win'>;
+type TState = {
+    isPending: boolean;
+    error: TRoundsHistoryError;
+    rounds: THistoryRoundData[];
+    selectedRoundUUID: string;
+    replayRound: TReplayRoundData;
+    replayStatus: TReplayStatus;
+    fake: TApiRoundsHistoryFake;
+};
+export type TRoundsHistoryError = {
+    name: string;
+    message: string;
+};
+export declare const setRoundsHistoryRounds: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<THistoryRoundData[], "roundsHistory/setRoundsHistoryRounds">, setRoundsHistorySelectedRoundUUID: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<string, "roundsHistory/setRoundsHistorySelectedRoundUUID">, setRoundsHistoryReplayStatus: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TReplayStatus, "roundsHistory/setRoundsHistoryReplayStatus">, fetchRoundsHistory: import("@reduxjs/toolkit").AsyncThunk<TRoundsHistoryResponse, object, {
+    rejectValue: TRoundsHistoryError;
+}>, clearRoundsHistory: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"roundsHistory/clearRoundsHistory">, setRoundsHistoryFake: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TApiRoundsHistoryFake, "roundsHistory/setRoundsHistoryFake">, setRoundsHistoryReplayRoundData: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TReplayRoundData, "roundsHistory/setRoundsHistoryReplayRoundData">;
+export declare const roundsHistoryReducer: import("redux").Reducer<TState>;
+export {};

package/dist/types/src/entities/roundsHistory/ui/RoundsHistoryCard.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+type TProps = {
+    isoDate: string;
+    bet: number;
+    win: number;
+    onClick: () => void;
+};
+export declare const RoundsHistoryCard: FC<TProps>;
+export {};

package/dist/types/src/entities/roundsHistory/ui/RoundsHistoryNothingHere.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+type TProps = {
+    className: string;
+};
+export declare const RoundsHistoryNothingHere: FC<TProps>;
+export {};

package/dist/types/src/entities/roundsHistory/ui/RoundsHistoryPeriodSelector.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+import { TRoundsHistoryInterval } from "../../../shared/api/roundsHistory";
+type TProps = {
+    dateInterval: TRoundsHistoryInterval;
+    setDateInterval: (interval: TRoundsHistoryInterval) => void;
+};
+export declare const RoundsHistoryPeriodSelector: FC<TProps>;
+export {};

package/dist/types/src/entities/roundsHistory/ui/RoundsHistoryTable.d.ts

@@ -0,0 +1,6 @@
+import { FC, ReactNode } from 'react';
+type TProps = {
+    children: ReactNode;
+};
+export declare const RoundsHistoryTable: FC<TProps>;
+export {};

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

@@ -0,0 +1 @@
+export { decreaseBalance, initSession, isFakePartner, restoreBalance, restoreSessionNetValue, sessionReducer, setBalance, setSessionShouldResetNetValue, updateSessionNetValue, } from './model/sessionSlice';

package/dist/types/src/entities/session/model/sessionSlice.d.ts

@@ -0,0 +1,28 @@
+import { TSessionUrls } from "../../../shared/api/config/types";
+type TSessionState = {
+    isDemo: boolean;
+    partner: string;
+    balance: number;
+    balancePrevious: number;
+    netValue: number;
+    netValuePrevious: number;
+    shouldResetNetValue: boolean;
+    currency: string;
+    currencyDecimals: number;
+    urls: TSessionUrls;
+};
+export declare const initSession: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    isDemo: boolean;
+    partner: string;
+    balance: number;
+    currency: string;
+    currencyDecimals: number;
+    urls: TSessionUrls;
+}, "session/initSession">, setBalance: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "session/setBalance">, decreaseBalance: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "session/decreaseBalance">, restoreBalance: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"session/restoreBalance">, updateSessionNetValue: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "session/updateSessionNetValue">, restoreSessionNetValue: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"session/restoreSessionNetValue">, setSessionShouldResetNetValue: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"session/setSessionShouldResetNetValue">;
+export declare const isFakePartner: import("reselect").Selector<{
+    session: TSessionState;
+}, boolean, []> & {
+    unwrapped: (state: TSessionState) => boolean;
+};
+export declare const sessionReducer: import("redux").Reducer<TSessionState>;
+export {};

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

@@ -0,0 +1 @@
+export { blockSkipTooltip, closeSkipTooltip, setSkipEnabled, setSkipOptions, setTurboActive, skipReducer, skipStart, } from './model/skipSlice';

package/dist/types/src/entities/skip/model/skipSlice.d.ts

@@ -0,0 +1,18 @@
+import { TAppThunkAction } from "../../../shared/lib/store";
+type TSkipState = {
+    isEnabled: boolean;
+    isTurboActive: boolean;
+    turboRoundsDelay: number;
+    turboSkipDelay: number;
+    isTooltipActive: boolean;
+    shouldOpenTooltip: boolean;
+    tooltipCheckpoint: number;
+    isSkipCounterEnabled: boolean;
+    skipCounter: number;
+};
+export declare const closeSkipTooltip: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"skip/closeSkipTooltip">, setSkipOptions: import("@reduxjs/toolkit").ActionCreatorWithNonInferrablePayload<"skip/setSkipOptions">, blockSkipTooltip: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"skip/blockSkipTooltip">, enableSkipCounter: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"skip/enableSkipCounter">;
+export declare const skipStart: TAppThunkAction;
+export declare const setSkipEnabled: TAppThunkAction<boolean>;
+export declare const setTurboActive: TAppThunkAction<boolean>;
+export declare const skipReducer: import("redux").Reducer<TSkipState>;
+export {};

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

@@ -0,0 +1,8 @@
+export { useSoundListener } from './lib/useSoundListener';
+export { getSoundState, setSoundActive, setSoundEffects, setSoundEnd, setSoundInitConfig, setSoundMusic, setSoundVolume, soundReducer, } from './model/soundSlice';
+export { TSoundsConfig } from './model/types';
+export { GameSoundControl } from './ui/GameSoundControl/GameSoundControl';
+export { SoundRangeEffects } from './ui/SoundRange/SoundRangeEffects';
+export { SoundRangeMusic } from './ui/SoundRange/SoundRangeMusic';
+export { SoundRangeVolume } from './ui/SoundRange/SoundRangeVolume';
+export { SoundSettingsSwitcher } from './ui/SoundSettingsSwitcher/SoundSettingsSwitcher';

package/dist/types/src/entities/sound/lib/useSoundListener.d.ts

@@ -0,0 +1 @@
+export declare const useSoundListener: () => void;

package/dist/types/src/entities/sound/model/soundSlice.d.ts

@@ -0,0 +1,72 @@
+import { TSoundsConfig } from './types';
+type TSoundState = {
+    isActive: boolean;
+    isDragging: boolean;
+    isChangedByUser: boolean;
+    lastOffParam: 'effects' | 'music' | null;
+    volume: {
+        current: number;
+        store: number;
+    };
+    effects: {
+        current: number;
+        store: number;
+    };
+    music: {
+        current: number;
+        store: number;
+    };
+};
+export declare const setSoundActive: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "sound/setSoundActive">, setSoundVolume: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "sound/setSoundVolume">, setSoundEffects: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "sound/setSoundEffects">, setSoundMusic: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number, "sound/setSoundMusic">, setSoundEnd: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"sound/setSoundEnd">, setSoundInitConfig: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<TSoundsConfig, "sound/setSoundInitConfig">;
+export declare const getSoundState: import("reselect").Selector<{
+    sound: TSoundState;
+}, {
+    isActive: boolean;
+    volume: number;
+    music: number;
+    effects: number;
+}, []> & {
+    unwrapped: ((state: TSoundState) => {
+        isActive: boolean;
+        volume: number;
+        music: number;
+        effects: number;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: number, resultFuncArgs_2: number, resultFuncArgs_3: number) => {
+            isActive: boolean;
+            volume: number;
+            music: number;
+            effects: number;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: number, resultFuncArgs_2: number, resultFuncArgs_3: number) => {
+            isActive: boolean;
+            volume: number;
+            music: number;
+            effects: number;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            isActive: boolean;
+            volume: number;
+            music: number;
+            effects: number;
+        };
+        dependencies: [(state: TSoundState) => boolean, (state: TSoundState) => number, (state: TSoundState) => number, (state: TSoundState) => number];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    };
+};
+export declare const soundReducer: import("redux").Reducer<TSoundState>;
+export {};

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

@@ -0,0 +1,7 @@
+export type TSoundsConfig = {
+    initialVolume: {
+        volume: number;
+        effects: number;
+        music: number;
+    };
+};

package/dist/types/src/entities/sound/ui/GameSoundControl/GameSoundControl.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+type TGameSoundControlProps = {
+    className?: string;
+};
+export declare const GameSoundControl: FC<TGameSoundControlProps>;
+export {};

package/dist/types/src/entities/sound/ui/SoundRange/SoundRangeEffects.d.ts

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

package/dist/types/src/entities/sound/ui/SoundRange/SoundRangeMusic.d.ts

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

package/dist/types/src/entities/sound/ui/SoundRange/SoundRangeVolume.d.ts

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

package/dist/types/src/entities/sound/ui/SoundSettingsSwitcher/SoundSettingsSwitcher.d.ts

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

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

@@ -0,0 +1,4 @@
+export { applyStakeStored, getStakeAmounts, getStakeDefaultAmounts, getStakeMaxBetData, getStakeMinBetData, getStakeType, persistStakeTransform, saveStakeStored, setStake, setStakeAmountsMap, setStakeAmountsMapByLevels, setStakeDefault, setStakeIsVisibleDropdown, setStakeLevels, setStakeMaxBet, setStakeMinBet, setStakeModes, setStakeNextAmount, setStakeNextLevel, setStakePreviousAmount, setStakePreviousLevel, setStakeStored, stakeReducer, } from './model/stakeSlice';
+export { PanelStakeAmounts } from './ui/PanelStakeAmounts/PanelStakeAmounts';
+export { StakeAmountDropdown } from './ui/StakeAmountDropdown/StakeAmountDropdown';
+export { StakeAmountSelector } from './ui/StakeAmountSelector/StakeAmountSelector';