jp.ui.app.toolkit 1.0.50 → 1.0.52

package/dist/src/data/slices/index.d.ts

@@ -4,9 +4,19 @@ import { shopScreenSlice } from './shop-screen-slice';
 import { tablesScreenSlice } from './tables-screen-slice';
 import { raiseBottomSheetBlockSlice } from './raise-bottom-sheet-block-slice';
 import { reactionBottomSheetBlockSlice } from './reaction-bottom-sheet-block-slice';
+import { oneTableTournamentStatusScreenSlice } from './one-table-tournament-status-screen-slice';
+import { manyTablesTournamentStatusScreenSlice } from './many-tables-tournament-status-screen-slice';
+import { manyTablesTournamentTableListScreenSlice } from './many-tables-tournament-table-list-screen-slice';
 import { wsConnectorSlice } from './ws-connector-slice';
-import { gameTableScreenSlice } from './game-table-screen-slice';
-export { appSlice, menuScreenSlice, shopScreenSlice, tablesScreenSlice, raiseBottomSheetBlockSlice, reactionBottomSheetBlockSlice, wsConnectorSlice, gameTableScreenSlice, };
+import { rulesScreenSlice } from './rules-screen-slice';
+import { friendsScreenSlice } from './friends-screen-slice';
+import { ratingScreenSlice } from './rating-screen-slice';
+import { premiumScreenSlice } from './premium-screen-slice';
+import { dailyBonusScreenSlice } from './daily-bonus-screen-slice';
+import { welcomeScreenSlice } from './welcome-screen-slice';
+import { settingsScreenSlice } from './settings-screen-slice';
+import { gameStatisticScreenSlice } from './game-statistic-screen-slice';
+export { appSlice, menuScreenSlice, shopScreenSlice, dailyBonusScreenSlice, rulesScreenSlice, welcomeScreenSlice, settingsScreenSlice, friendsScreenSlice, premiumScreenSlice, gameStatisticScreenSlice, ratingScreenSlice, tablesScreenSlice, raiseBottomSheetBlockSlice, reactionBottomSheetBlockSlice, oneTableTournamentStatusScreenSlice, manyTablesTournamentStatusScreenSlice, manyTablesTournamentTableListScreenSlice, wsConnectorSlice, };
 export declare function getBaseSlices(): (import("@reduxjs/toolkit").Slice<import("./app-slice").AppSlice, {
     initApp: (state: import("./app-slice").AppSlice) => {
         isLoading: boolean;
@@ -35,13 +45,13 @@ export declare function getBaseSlices(): (import("@reduxjs/toolkit").Slice<impor
 }> | import("@reduxjs/toolkit").Slice<import("./menu-screen-slice").MenuScreenState, {
     start: (state: import("./menu-screen-slice").MenuScreenState) => {
         isLoading: boolean;
-        isError: null;
-        data: null;
+        isError: boolean;
+        data: undefined;
     };
     error: (state: import("./menu-screen-slice").MenuScreenState) => {
         isLoading: boolean;
         isError: boolean;
-        data?: import("jp.common.view").AppScreenTypes;
+        data: import("jp.common.view").AppScreenTypes | undefined;
     };
     success: (state: import("./menu-screen-slice").MenuScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
         isLoading: boolean;
@@ -57,13 +67,13 @@ export declare function getBaseSlices(): (import("@reduxjs/toolkit").Slice<impor
 }> | import("@reduxjs/toolkit").Slice<import("./shop-screen-slice").ShopScreenState, {
     start: (state: import("./shop-screen-slice").ShopScreenState) => {
         isLoading: boolean;
-        isError: null;
-        data: null;
+        isError: boolean;
+        data: undefined;
     };
     error: (state: import("./shop-screen-slice").ShopScreenState) => {
         isLoading: boolean;
         isError: boolean;
-        data?: import("jp.common.view").AppScreenTypes;
+        data: import("jp.common.view").AppScreenTypes | undefined;
     };
     success: (state: import("./shop-screen-slice").ShopScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
         isLoading: boolean;
@@ -78,13 +88,13 @@ export declare function getBaseSlices(): (import("@reduxjs/toolkit").Slice<impor
 }> | import("@reduxjs/toolkit").Slice<import("./tables-screen-slice").TablesScreenState, {
     start: (state: import("./tables-screen-slice").TablesScreenState) => {
         isLoading: boolean;
-        isError: null;
-        data: null;
+        isError: boolean;
+        data: undefined;
     };
     error: (state: import("./tables-screen-slice").TablesScreenState) => {
         isLoading: boolean;
         isError: boolean;
-        data?: import("jp.common.view").AppScreenTypes;
+        data?: import("jp.common.view").AppScreenTypes | undefined;
     };
     success: (state: import("./tables-screen-slice").TablesScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
         isLoading: boolean;
@@ -93,6 +103,7 @@ export declare function getBaseSlices(): (import("@reduxjs/toolkit").Slice<impor
     };
     init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
     listItemClick: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenSectionListItem>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+    backClick: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
 }, "tablesScreenSlice", "tablesScreenSlice", {
     getScreen: (sliceState: import("./tables-screen-slice").TablesScreenState) => import("jp.common.view").AppScreenTypes | undefined;
     isLoading: (sliceState: import("./tables-screen-slice").TablesScreenState) => boolean;
@@ -115,6 +126,69 @@ export declare function getBaseSlices(): (import("@reduxjs/toolkit").Slice<impor
     };
 }, "reactionBottomSheetBlockSlice", "reactionBottomSheetBlockSlice", {
     getIsOpen: (sliceState: import("./reaction-bottom-sheet-block-slice").ReactionBottomSheetBlockState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./one-table-tournament-status-screen-slice").OneTableTournamentStatusScreenState, {
+    start: (state: import("./one-table-tournament-status-screen-slice").OneTableTournamentStatusScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./one-table-tournament-status-screen-slice").OneTableTournamentStatusScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./one-table-tournament-status-screen-slice").OneTableTournamentStatusScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "oneTableTournamentStatusScreenSlice", "oneTableTournamentStatusScreenSlice", {
+    getScreen: (sliceState: import("./one-table-tournament-status-screen-slice").OneTableTournamentStatusScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./one-table-tournament-status-screen-slice").OneTableTournamentStatusScreenState) => boolean;
+    isError: (sliceState: import("./one-table-tournament-status-screen-slice").OneTableTournamentStatusScreenState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./many-tables-tournament-status-screen-slice").ManyTablesTournamentStatusScreenState, {
+    start: (state: import("./many-tables-tournament-status-screen-slice").ManyTablesTournamentStatusScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./many-tables-tournament-status-screen-slice").ManyTablesTournamentStatusScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./many-tables-tournament-status-screen-slice").ManyTablesTournamentStatusScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "manyTablesTournamentStatusScreenSlice", "manyTablesTournamentStatusScreenSlice", {
+    getScreen: (sliceState: import("./many-tables-tournament-status-screen-slice").ManyTablesTournamentStatusScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./many-tables-tournament-status-screen-slice").ManyTablesTournamentStatusScreenState) => boolean;
+    isError: (sliceState: import("./many-tables-tournament-status-screen-slice").ManyTablesTournamentStatusScreenState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./many-tables-tournament-table-list-screen-slice").ManyTablesTournamentTableListScreenState, {
+    start: (state: import("./many-tables-tournament-table-list-screen-slice").ManyTablesTournamentTableListScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./many-tables-tournament-table-list-screen-slice").ManyTablesTournamentTableListScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./many-tables-tournament-table-list-screen-slice").ManyTablesTournamentTableListScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "manyTablesTournamentTableListScreenSlice", "manyTablesTournamentTableListScreenSlice", {
+    getScreen: (sliceState: import("./many-tables-tournament-table-list-screen-slice").ManyTablesTournamentTableListScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./many-tables-tournament-table-list-screen-slice").ManyTablesTournamentTableListScreenState) => boolean;
+    isError: (sliceState: import("./many-tables-tournament-table-list-screen-slice").ManyTablesTournamentTableListScreenState) => boolean;
 }> | import("@reduxjs/toolkit").Slice<import("./ws-connector-slice").WsConnectorState, {
     connect: (state: import("./ws-connector-slice").WsConnectorState) => {
         isConnected: boolean;
@@ -132,16 +206,192 @@ export declare function getBaseSlices(): (import("@reduxjs/toolkit").Slice<impor
     message: (state: import("./ws-connector-slice").WsConnectorState, action: import("@reduxjs/toolkit").PayloadAction<object>) => import("./ws-connector-slice").WsConnectorState;
 }, "wsConnectorSlice", "wsConnectorSlice", {
     getIsConnected: (sliceState: import("./ws-connector-slice").WsConnectorState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./rules-screen-slice").rulesScreenState, {
+    start: (state: import("./rules-screen-slice").rulesScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./rules-screen-slice").rulesScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./rules-screen-slice").rulesScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "rulesScreenSlice", "rulesScreenSlice", {
+    getScreen: (sliceState: import("./rules-screen-slice").rulesScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./rules-screen-slice").rulesScreenState) => boolean;
+    isError: (sliceState: import("./rules-screen-slice").rulesScreenState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./friends-screen-slice").friendsScreenState, {
+    start: (state: import("./friends-screen-slice").friendsScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./friends-screen-slice").friendsScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./friends-screen-slice").friendsScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "friendsScreenSlice", "friendsScreenSlice", {
+    getScreen: (sliceState: import("./friends-screen-slice").friendsScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./friends-screen-slice").friendsScreenState) => boolean;
+    isError: (sliceState: import("./friends-screen-slice").friendsScreenState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./rating-screen-slice").ratingScreenState, {
+    start: (state: import("./rating-screen-slice").ratingScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./rating-screen-slice").ratingScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./rating-screen-slice").ratingScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "ratingScreenSlice", "ratingScreenSlice", {
+    getScreen: (sliceState: import("./rating-screen-slice").ratingScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./rating-screen-slice").ratingScreenState) => boolean;
+    isError: (sliceState: import("./rating-screen-slice").ratingScreenState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./premium-screen-slice").premiumScreenState, {
+    start: (state: import("./premium-screen-slice").premiumScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./premium-screen-slice").premiumScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./premium-screen-slice").premiumScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "premiumScreenSlice", "premiumScreenSlice", {
+    getScreen: (sliceState: import("./premium-screen-slice").premiumScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./premium-screen-slice").premiumScreenState) => boolean;
+    isError: (sliceState: import("./premium-screen-slice").premiumScreenState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./daily-bonus-screen-slice").dailyBonusScreenState, {
+    start: (state: import("./daily-bonus-screen-slice").dailyBonusScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./daily-bonus-screen-slice").dailyBonusScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./daily-bonus-screen-slice").dailyBonusScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "dailyBonusScreenSlice", "dailyBonusScreenSlice", {
+    getScreen: (sliceState: import("./daily-bonus-screen-slice").dailyBonusScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./daily-bonus-screen-slice").dailyBonusScreenState) => boolean;
+    isError: (sliceState: import("./daily-bonus-screen-slice").dailyBonusScreenState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./welcome-screen-slice").welcomeScreenState, {
+    start: (state: import("./welcome-screen-slice").welcomeScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./welcome-screen-slice").welcomeScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./welcome-screen-slice").welcomeScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "welcomeScreenSlice", "welcomeScreenSlice", {
+    getScreen: (sliceState: import("./welcome-screen-slice").welcomeScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./welcome-screen-slice").welcomeScreenState) => boolean;
+    isError: (sliceState: import("./welcome-screen-slice").welcomeScreenState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./settings-screen-slice").settingsScreenState, {
+    start: (state: import("./settings-screen-slice").settingsScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./settings-screen-slice").settingsScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./settings-screen-slice").settingsScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "settingsScreenSlice", "settingsScreenSlice", {
+    getScreen: (sliceState: import("./settings-screen-slice").settingsScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./settings-screen-slice").settingsScreenState) => boolean;
+    isError: (sliceState: import("./settings-screen-slice").settingsScreenState) => boolean;
+}> | import("@reduxjs/toolkit").Slice<import("./game-statistic-screen-slice").gameStatisticScreenState, {
+    start: (state: import("./game-statistic-screen-slice").gameStatisticScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: import("./game-statistic-screen-slice").gameStatisticScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    success: (state: import("./game-statistic-screen-slice").gameStatisticScreenState, action: import("@reduxjs/toolkit").PayloadAction<import("jp.common.view").AppScreenTypes | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: import("jp.common.view").AppScreenTypes | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "gameStatisticScreenSlice", "gameStatisticScreenSlice", {
+    getScreen: (sliceState: import("./game-statistic-screen-slice").gameStatisticScreenState) => import("jp.common.view").AppScreenTypes | undefined;
+    isLoading: (sliceState: import("./game-statistic-screen-slice").gameStatisticScreenState) => boolean;
+    isError: (sliceState: import("./game-statistic-screen-slice").gameStatisticScreenState) => boolean;
 }>)[];
 export declare function getBaseSlicesReducer(): {
     appSlice: import("redux").Reducer<import("./app-slice").AppSlice>;
     menuScreenSlice: import("redux").Reducer<import("./menu-screen-slice").MenuScreenState>;
     shopScreenSlice: import("redux").Reducer<import("./shop-screen-slice").ShopScreenState>;
+    rulesScreenSlice: import("redux").Reducer<import("./rules-screen-slice").rulesScreenState>;
+    welcomeScreenSlice: import("redux").Reducer<import("./welcome-screen-slice").welcomeScreenState>;
+    dailyBonusScreenSlice: import("redux").Reducer<import("./daily-bonus-screen-slice").dailyBonusScreenState>;
+    settingsScreenSlice: import("redux").Reducer<import("./settings-screen-slice").settingsScreenState>;
+    premiumScreenSlice: import("redux").Reducer<import("./premium-screen-slice").premiumScreenState>;
+    friendsScreenSlice: import("redux").Reducer<import("./friends-screen-slice").friendsScreenState>;
+    gameStatisticScreenSlice: import("redux").Reducer<import("./game-statistic-screen-slice").gameStatisticScreenState>;
+    ratingScreenSlice: import("redux").Reducer<import("./rating-screen-slice").ratingScreenState>;
     tablesScreenSlice: import("redux").Reducer<import("./tables-screen-slice").TablesScreenState>;
     raiseBottomSheetBlockSlice: import("redux").Reducer<import("./raise-bottom-sheet-block-slice").RaiseBottomSheetBlockState>;
     reactionBottomSheetBlockSlice: import("redux").Reducer<import("./reaction-bottom-sheet-block-slice").ReactionBottomSheetBlockState>;
+    oneTableTournamentStatusScreenSlice: import("redux").Reducer<import("./one-table-tournament-status-screen-slice").OneTableTournamentStatusScreenState>;
+    manyTablesTournamentStatusScreenSlice: import("redux").Reducer<import("./many-tables-tournament-status-screen-slice").ManyTablesTournamentStatusScreenState>;
+    manyTablesTournamentTableListScreenSlice: import("redux").Reducer<import("./many-tables-tournament-table-list-screen-slice").ManyTablesTournamentTableListScreenState>;
     wsConnectorSlice: import("redux").Reducer<import("./ws-connector-slice").WsConnectorState>;
-    gameTableScreenSlice: import("redux").Reducer<import("./game-table-screen-slice/reducer/reducer").IBaseTableScreenState> & {
-        getInitialState: () => import("./game-table-screen-slice/reducer/reducer").IBaseTableScreenState;
-    };
 };

package/dist/src/data/slices/many-tables-tournament-status-screen-slice.d.ts

@@ -0,0 +1,31 @@
+import type { PayloadAction } from '@reduxjs/toolkit';
+import type { AppScreenTypeEnum } from 'jp.common.models';
+export interface ManyTablesTournamentStatusScreenState {
+    isLoading: boolean;
+    isError: boolean;
+    data: AppScreenTypeEnum | undefined;
+}
+export declare const manyTablesTournamentStatusScreenSlice: import("@reduxjs/toolkit").Slice<ManyTablesTournamentStatusScreenState, {
+    start: (state: ManyTablesTournamentStatusScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: ManyTablesTournamentStatusScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    success: (state: ManyTablesTournamentStatusScreenState, action: PayloadAction<AppScreenTypeEnum | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "manyTablesTournamentStatusScreenSlice", "manyTablesTournamentStatusScreenSlice", {
+    getScreen: (sliceState: ManyTablesTournamentStatusScreenState) => AppScreenTypeEnum | undefined;
+    isLoading: (sliceState: ManyTablesTournamentStatusScreenState) => boolean;
+    isError: (sliceState: ManyTablesTournamentStatusScreenState) => boolean;
+}>;
+declare const _default: import("redux").Reducer<ManyTablesTournamentStatusScreenState>;
+export default _default;

package/dist/src/data/slices/many-tables-tournament-table-list-screen-slice.d.ts

@@ -0,0 +1,31 @@
+import type { PayloadAction } from '@reduxjs/toolkit';
+import type { AppScreenTypeEnum } from 'jp.common.models';
+export interface ManyTablesTournamentTableListScreenState {
+    isLoading: boolean;
+    isError: boolean;
+    data: AppScreenTypeEnum | undefined;
+}
+export declare const manyTablesTournamentTableListScreenSlice: import("@reduxjs/toolkit").Slice<ManyTablesTournamentTableListScreenState, {
+    start: (state: ManyTablesTournamentTableListScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: ManyTablesTournamentTableListScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    success: (state: ManyTablesTournamentTableListScreenState, action: PayloadAction<AppScreenTypeEnum | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "manyTablesTournamentTableListScreenSlice", "manyTablesTournamentTableListScreenSlice", {
+    getScreen: (sliceState: ManyTablesTournamentTableListScreenState) => AppScreenTypeEnum | undefined;
+    isLoading: (sliceState: ManyTablesTournamentTableListScreenState) => boolean;
+    isError: (sliceState: ManyTablesTournamentTableListScreenState) => boolean;
+}>;
+declare const _default: import("redux").Reducer<ManyTablesTournamentTableListScreenState>;
+export default _default;

package/dist/src/data/slices/menu-screen-slice.d.ts

@@ -1,30 +1,30 @@
 import type { PayloadAction } from '@reduxjs/toolkit';
-import type { AppScreenSectionListItem, AppScreenTypes } from 'jp.common.view';
+import type { AppScreenSectionListItem, AppScreenTypeEnum } from 'jp.common.models';
 export interface MenuScreenState {
     isLoading: boolean;
     isError: boolean;
-    data?: AppScreenTypes;
+    data: AppScreenTypeEnum | undefined;
 }
 export declare const menuScreenSlice: import("@reduxjs/toolkit").Slice<MenuScreenState, {
     start: (state: MenuScreenState) => {
         isLoading: boolean;
-        isError: null;
-        data: null;
+        isError: boolean;
+        data: undefined;
     };
     error: (state: MenuScreenState) => {
         isLoading: boolean;
         isError: boolean;
-        data?: AppScreenTypes;
+        data: AppScreenTypeEnum | undefined;
     };
-    success: (state: MenuScreenState, action: PayloadAction<AppScreenTypes | undefined>) => {
+    success: (state: MenuScreenState, action: PayloadAction<AppScreenTypeEnum | undefined>) => {
         isLoading: boolean;
         isError: boolean;
-        data: AppScreenTypes | undefined;
+        data: AppScreenTypeEnum | undefined;
     };
     init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
     listItemClick: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>, action: PayloadAction<AppScreenSectionListItem>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
 }, "menuScreenSlice", "menuScreenSlice", {
-    getScreen: (sliceState: MenuScreenState) => AppScreenTypes | undefined;
+    getScreen: (sliceState: MenuScreenState) => AppScreenTypeEnum | undefined;
     isLoading: (sliceState: MenuScreenState) => boolean;
     isError: (sliceState: MenuScreenState) => boolean;
 }>;

package/dist/src/data/slices/one-table-tournament-status-screen-slice.d.ts

@@ -0,0 +1,31 @@
+import type { PayloadAction } from '@reduxjs/toolkit';
+import type { AppScreenTypeEnum } from 'jp.common.models';
+export interface OneTableTournamentStatusScreenState {
+    isLoading: boolean;
+    isError: boolean;
+    data: AppScreenTypeEnum | undefined;
+}
+export declare const oneTableTournamentStatusScreenSlice: import("@reduxjs/toolkit").Slice<OneTableTournamentStatusScreenState, {
+    start: (state: OneTableTournamentStatusScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: OneTableTournamentStatusScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    success: (state: OneTableTournamentStatusScreenState, action: PayloadAction<AppScreenTypeEnum | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "oneTableTournamentStatusScreenSlice", "oneTableTournamentStatusScreenSlice", {
+    getScreen: (sliceState: OneTableTournamentStatusScreenState) => AppScreenTypeEnum | undefined;
+    isLoading: (sliceState: OneTableTournamentStatusScreenState) => boolean;
+    isError: (sliceState: OneTableTournamentStatusScreenState) => boolean;
+}>;
+declare const _default: import("redux").Reducer<OneTableTournamentStatusScreenState>;
+export default _default;

package/dist/src/data/slices/players-profile-screen-slice.d.ts

@@ -0,0 +1,32 @@
+import type { PayloadAction } from '@reduxjs/toolkit';
+import type { AppScreenTypeEnum } from 'jp.common.models';
+export interface playersProfileScreenState {
+    isLoading: boolean;
+    isError: boolean;
+    data: AppScreenTypeEnum | undefined;
+}
+export declare const playersProfileScreenSlice: import("@reduxjs/toolkit").Slice<playersProfileScreenState, {
+    start: (state: playersProfileScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: playersProfileScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    success: (state: playersProfileScreenState, action: PayloadAction<AppScreenTypeEnum | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+    backClick: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "playersProfileScreenSlice", "playersProfileScreenSlice", {
+    getScreen: (sliceState: playersProfileScreenState) => AppScreenTypeEnum | undefined;
+    isLoading: (sliceState: playersProfileScreenState) => boolean;
+    isError: (sliceState: playersProfileScreenState) => boolean;
+}>;
+declare const _default: import("redux").Reducer<playersProfileScreenState>;
+export default _default;

package/dist/src/data/slices/premium-screen-slice.d.ts

@@ -0,0 +1,32 @@
+import type { PayloadAction } from '@reduxjs/toolkit';
+import type { AppScreenTypeEnum } from 'jp.common.models';
+export interface premiumScreenState {
+    isLoading: boolean;
+    isError: boolean;
+    data: AppScreenTypeEnum | undefined;
+}
+export declare const premiumScreenSlice: import("@reduxjs/toolkit").Slice<premiumScreenState, {
+    start: (state: premiumScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: premiumScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    success: (state: premiumScreenState, action: PayloadAction<AppScreenTypeEnum | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+    backClick: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "premiumScreenSlice", "premiumScreenSlice", {
+    getScreen: (sliceState: premiumScreenState) => AppScreenTypeEnum | undefined;
+    isLoading: (sliceState: premiumScreenState) => boolean;
+    isError: (sliceState: premiumScreenState) => boolean;
+}>;
+declare const _default: import("redux").Reducer<premiumScreenState>;
+export default _default;

package/dist/src/data/slices/rating-screen-slice.d.ts

@@ -0,0 +1,32 @@
+import type { PayloadAction } from '@reduxjs/toolkit';
+import type { AppScreenTypeEnum } from 'jp.common.models';
+export interface ratingScreenState {
+    isLoading: boolean;
+    isError: boolean;
+    data: AppScreenTypeEnum | undefined;
+}
+export declare const ratingScreenSlice: import("@reduxjs/toolkit").Slice<ratingScreenState, {
+    start: (state: ratingScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: ratingScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    success: (state: ratingScreenState, action: PayloadAction<AppScreenTypeEnum | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+    backClick: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "ratingScreenSlice", "ratingScreenSlice", {
+    getScreen: (sliceState: ratingScreenState) => AppScreenTypeEnum | undefined;
+    isLoading: (sliceState: ratingScreenState) => boolean;
+    isError: (sliceState: ratingScreenState) => boolean;
+}>;
+declare const _default: import("redux").Reducer<ratingScreenState>;
+export default _default;

package/dist/src/data/slices/rules-screen-slice.d.ts

@@ -0,0 +1,32 @@
+import type { PayloadAction } from '@reduxjs/toolkit';
+import type { AppScreenTypeEnum } from 'jp.common.models';
+export interface rulesScreenState {
+    isLoading: boolean;
+    isError: boolean;
+    data: AppScreenTypeEnum | undefined;
+}
+export declare const rulesScreenSlice: import("@reduxjs/toolkit").Slice<rulesScreenState, {
+    start: (state: rulesScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: undefined;
+    };
+    error: (state: rulesScreenState) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    success: (state: rulesScreenState, action: PayloadAction<AppScreenTypeEnum | undefined>) => {
+        isLoading: boolean;
+        isError: boolean;
+        data: AppScreenTypeEnum | undefined;
+    };
+    init: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+    backClick: (state: Map<import("immer").Draft<K>, import("immer").Draft<V>>) => Map<import("immer").Draft<K>, import("immer").Draft<V>>;
+}, "rulesScreenSlice", "rulesScreenSlice", {
+    getScreen: (sliceState: rulesScreenState) => AppScreenTypeEnum | undefined;
+    isLoading: (sliceState: rulesScreenState) => boolean;
+    isError: (sliceState: rulesScreenState) => boolean;
+}>;
+declare const _default: import("redux").Reducer<rulesScreenState>;
+export default _default;