game_client_logic_deb 1.6.37 → 1.6.55

package/Logic_Debertz-game_client.d.ts

@@ -4,12 +4,107 @@ export declare namespace com.logic {
         get version(): string;
     };
 }
+export declare namespace com.logic.data.models {
+    class CoreConfig {
+        constructor(fileLogsEnabled?: boolean, deleteFilesOnClear?: boolean, logsDirectoryPath?: Nullable<string>, fileNameFormat?: string);
+        get fileLogsEnabled(): boolean;
+        get deleteFilesOnClear(): boolean;
+        get logsDirectoryPath(): Nullable<string>;
+        get fileNameFormat(): string;
+        copy(fileLogsEnabled?: boolean, deleteFilesOnClear?: boolean, logsDirectoryPath?: Nullable<string>, fileNameFormat?: string): com.logic.data.models.CoreConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
 export declare namespace com.logic.data.models {
     abstract class TerminationGameReason {
         protected constructor();
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
+    class PlayerLostConnectionReason extends com.logic.data.models.TerminationGameReason /* implements com.logic.data.models.FinishPlayerReason */ {
+        constructor(playerId: string, tag: Nullable<string>);
+        get tag(): Nullable<string>;
+        copy(playerId?: string, tag?: Nullable<string>): com.logic.data.models.PlayerLostConnectionReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+        };
+    }
+    class PlayerTimeoutReason extends com.logic.data.models.TerminationGameReason /* implements com.logic.data.models.FinishPlayerReason */ {
+        constructor(playerId: string, tag: Nullable<string>);
+        get tag(): Nullable<string>;
+        copy(playerId?: string, tag?: Nullable<string>): com.logic.data.models.PlayerTimeoutReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+        };
+    }
+    class PlayerExitReason extends com.logic.data.models.TerminationGameReason /* implements com.logic.data.models.FinishPlayerReason */ {
+        constructor(playerId: string);
+        copy(playerId?: string): com.logic.data.models.PlayerExitReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+        };
+    }
+    class GameFinishedReason extends com.logic.data.models.TerminationGameReason {
+        constructor(reason: com.logic.data.models.GameFinishedReason.Reason);
+        get reason(): com.logic.data.models.GameFinishedReason.Reason;
+        copy(reason?: com.logic.data.models.GameFinishedReason.Reason): com.logic.data.models.GameFinishedReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+        };
+    }
+    namespace GameFinishedReason {
+        abstract class Reason {
+            private constructor();
+            static get DEPLOY(): com.logic.data.models.GameFinishedReason.Reason & {
+                get name(): "DEPLOY";
+                get ordinal(): 0;
+            };
+            static get PLAYER_DELETED(): com.logic.data.models.GameFinishedReason.Reason & {
+                get name(): "PLAYER_DELETED";
+                get ordinal(): 1;
+            };
+            static get NO_ACTIVE_PLAYERS(): com.logic.data.models.GameFinishedReason.Reason & {
+                get name(): "NO_ACTIVE_PLAYERS";
+                get ordinal(): 2;
+            };
+            static get GAME_NOT_EXISTS(): com.logic.data.models.GameFinishedReason.Reason & {
+                get name(): "GAME_NOT_EXISTS";
+                get ordinal(): 3;
+            };
+            static values(): Array<com.logic.data.models.GameFinishedReason.Reason>;
+            static valueOf(value: string): com.logic.data.models.GameFinishedReason.Reason;
+            get name(): "DEPLOY" | "PLAYER_DELETED" | "NO_ACTIVE_PLAYERS" | "GAME_NOT_EXISTS";
+            get ordinal(): 0 | 1 | 2 | 3;
+            static get Companion(): {
+            } & any/* kotlinx.serialization.internal.SerializerFactory */;
+        }
+    }
+    class GameErrorReason extends com.logic.data.models.TerminationGameReason {
+        constructor(reason: string);
+        get reason(): string;
+        copy(reason?: string): com.logic.data.models.GameErrorReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+        };
+    }
+    const WaitingForConnectionReason: {
+        toString(): string;
+    } & com.logic.data.models.TerminationGameReason & any/* kotlinx.serialization.internal.SerializerFactory */;
+    const ProcessingReason: {
+        toString(): string;
+    } & com.logic.data.models.TerminationGameReason & any/* kotlinx.serialization.internal.SerializerFactory */;
 }
 export declare namespace com.logic.data.models.player {
     class GameUserInfo implements com.logic.data.models.player.PlayerIdContract {
@@ -158,38 +253,46 @@ export declare namespace com.logic.data.models.rules {
         get ordinal(): 0 | 1 | 2 | 3 | 4;
     }
 }
-export declare namespace com.logic.domain.engine.definitions {
-    interface Action {
-        readonly actionTag: string;
-        readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.domain.engine.definitions.Action": unique symbol;
-        };
-    }
-}
-export declare namespace com.logic.domain.engine.definitions {
-    interface Store<State> {
-        readonly store: com.logic.domain.engine.definitions.Store<State>;
-        dispatch: (p0: com.logic.domain.engine.definitions.Action) => void;
-        readonly observe: any/* kotlinx.coroutines.flow.Flow<State> */;
-        readonly replaceReducer: (p0: any/* com.logic.domain.engine.definitions.Reducer<State> */) => void;
-        readonly state: State;
-        readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.domain.engine.definitions.Store": unique symbol;
+export declare namespace com.logic.data.models.serializable.rules {
+    class RulesDto {
+        constructor(needToPutHigherTrump: Nullable<boolean> | undefined, distributePoints: Nullable<boolean> | undefined, protectBella: Nullable<boolean> | undefined, oneTryToProtectBella: Nullable<boolean> | undefined, enableFourSevensCombination: Nullable<boolean> | undefined, enableTrumpSevenCombination: Nullable<boolean> | undefined, enableTrumpSevenCombinationAfterDistribution: Nullable<boolean> | undefined, playerWhoChooseSuitGoFirst: Nullable<boolean> | undefined, winnerShuffleCards: Nullable<boolean> | undefined, playWithoutLiabilities: Nullable<boolean> | undefined, trumpCardGoToPlayerWhoShuffleCards: Nullable<boolean> | undefined, enableFineIfNoBribes: Nullable<boolean> | undefined, fineIfNoBribes: number, enableFineAfterThirdByte?: Nullable<boolean>, checkTrumpCombination?: Nullable<boolean>, checkOnlyTrumpDebertz?: Nullable<boolean>, tenCardsInHand?: Nullable<boolean>);
+        get needToPutHigherTrump(): Nullable<boolean>;
+        get distributePoints(): Nullable<boolean>;
+        get protectBella(): Nullable<boolean>;
+        get oneTryToProtectBella(): Nullable<boolean>;
+        get enableFourSevensCombination(): Nullable<boolean>;
+        get enableTrumpSevenCombination(): Nullable<boolean>;
+        get enableTrumpSevenCombinationAfterDistribution(): Nullable<boolean>;
+        get playerWhoChooseSuitGoFirst(): Nullable<boolean>;
+        get winnerShuffleCards(): Nullable<boolean>;
+        get playWithoutLiabilities(): Nullable<boolean>;
+        get trumpCardGoToPlayerWhoShuffleCards(): Nullable<boolean>;
+        get enableFineIfNoBribes(): Nullable<boolean>;
+        get fineIfNoBribes(): number;
+        get enableFineAfterThirdByte(): Nullable<boolean>;
+        get checkTrumpCombination(): Nullable<boolean>;
+        get checkOnlyTrumpDebertz(): Nullable<boolean>;
+        get tenCardsInHand(): Nullable<boolean>;
+        copy(needToPutHigherTrump?: Nullable<boolean>, distributePoints?: Nullable<boolean>, protectBella?: Nullable<boolean>, oneTryToProtectBella?: Nullable<boolean>, enableFourSevensCombination?: Nullable<boolean>, enableTrumpSevenCombination?: Nullable<boolean>, enableTrumpSevenCombinationAfterDistribution?: Nullable<boolean>, playerWhoChooseSuitGoFirst?: Nullable<boolean>, winnerShuffleCards?: Nullable<boolean>, playWithoutLiabilities?: Nullable<boolean>, trumpCardGoToPlayerWhoShuffleCards?: Nullable<boolean>, enableFineIfNoBribes?: Nullable<boolean>, fineIfNoBribes?: number, enableFineAfterThirdByte?: Nullable<boolean>, checkTrumpCombination?: Nullable<boolean>, checkOnlyTrumpDebertz?: Nullable<boolean>, tenCardsInHand?: Nullable<boolean>): com.logic.data.models.serializable.rules.RulesDto;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
         };
     }
 }
 export declare namespace com.logic.redux.actions {
-    interface BufferedAction extends com.logic.domain.engine.definitions.Action {
+    interface BufferedAction extends com.logic.redux.store.definitions.Action {
         readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.redux.actions.BufferedAction": unique symbol;
-        } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
-    interface ReleaseBufferTriggerAction extends com.logic.domain.engine.definitions.Action {
+    interface ReleaseBufferTriggerAction extends com.logic.redux.store.definitions.Action {
         readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.redux.actions.ReleaseBufferTriggerAction": unique symbol;
-        } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace com.logic.redux.actions.validation {
@@ -208,6 +311,26 @@ export declare namespace com.logic.redux.actions.validation {
         };
     }
 }
+export declare namespace com.logic.redux.store.definitions {
+    interface Action {
+        readonly actionTag: string;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.redux.store.definitions.Action": unique symbol;
+        };
+    }
+}
+export declare namespace com.logic.redux.store.definitions {
+    interface Store<State> {
+        readonly store: com.logic.redux.store.definitions.Store<State>;
+        dispatch: (p0: com.logic.redux.store.definitions.Action) => void;
+        readonly observe: any/* kotlinx.coroutines.flow.Flow<State> */;
+        readonly replaceReducer: (p0: any/* com.logic.redux.store.definitions.Reducer<State> */) => void;
+        readonly state: State;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.redux.store.definitions.Store": unique symbol;
+        };
+    }
+}
 export declare namespace com.logic.utils.logger.game {
     interface GameLogger extends com.logic.utils.logger.outputs.LoggerOutput {
         d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
@@ -286,6 +409,7 @@ export declare namespace com.logic.utils.logger.outputs {
         get tag(): Nullable<string>;
         get message(): Nullable<string>;
         get stackTrace(): Nullable<string>;
+        toMessageLog(): string;
         copy(type?: com.logic.utils.logger.outputs.LogType, tag?: Nullable<string>, message?: Nullable<string>, stackTrace?: Nullable<string>): com.logic.utils.logger.outputs.LoggerOutputDataDto;
         toString(): string;
         hashCode(): number;
@@ -652,15 +776,15 @@ export declare namespace com.debertz.logic.redux.actions {
         get actionTag(): string;
         notValidateWhenFinishing(): boolean;
         notValidateWhenFinished(): boolean;
-        readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
-    } & com.logic.domain.engine.definitions.Action & com.logic.redux.actions.validation.NotValidateIfGameFinishing & com.logic.redux.actions.validation.NotValidateIfGameFinished;
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
+    } & com.logic.redux.store.definitions.Action & com.logic.redux.actions.validation.NotValidateIfGameFinishing & com.logic.redux.actions.validation.NotValidateIfGameFinished;
 }
 export declare namespace com.debertz.logic.redux.actions.client.from {
-    abstract class FromClientAction implements com.logic.domain.engine.definitions.Action {
+    abstract class FromClientAction implements com.logic.redux.store.definitions.Action {
         protected constructor();
         abstract get playerId(): string;
         get actionTag(): string;
-        readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace com.debertz.logic.redux.actions.client.to {
@@ -675,8 +799,8 @@ export declare namespace com.debertz.logic.redux.actions.client.to {
         get excludePlayerId(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        copy(id?: string, includePlayers?: Array<string>, excludePlayers?: Array<string>, deliveryType?: com.debertz.logic.redux.actions.client.to.ActionDeliveryType): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
         toString(): string;
+        copy(id?: string, includePlayers?: Array<string>, excludePlayers?: Array<string>, deliveryType?: com.debertz.logic.redux.actions.client.to.ActionDeliveryType): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
         static get Companion(): {
             user(tableId: string, sendToPlayerId: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
         };
@@ -704,18 +828,18 @@ export declare namespace com.debertz.logic.redux.actions.client.to {
     }
 }
 export declare namespace com.debertz.logic.redux.actions.client.to {
-    abstract class ToClientAction implements com.logic.domain.engine.definitions.Action {
+    abstract class ToClientAction implements com.logic.redux.store.definitions.Action {
         protected constructor();
         abstract get deliveryPayload(): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
         get actionTag(): string;
-        readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace com.debertz.logic.redux.actions.game {
-    abstract class GameAction implements com.logic.domain.engine.definitions.Action {
+    abstract class GameAction implements com.logic.redux.store.definitions.Action {
         protected constructor();
         get actionTag(): string;
-        readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
     class RoundStartedAction extends com.debertz.logic.redux.actions.game.GameAction {
         constructor(id: string, gameId: string, roundNumber: number, players: Array<string>, isFirstRound: boolean, gameNumber: number, gameHistory: com.debertz.logic.data.models.table.history.GameHistory);
@@ -751,7 +875,7 @@ export declare namespace com.debertz.logic.redux.actions.game {
         copy(id?: string, gameId?: string, roundNumber?: number, earnedBiggestPointPlayerId?: string, roundCommitted?: Array<string>, roundWinners?: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>, luckyFactors?: Nullable<Array<com.logic.data.models.player.PlayerLuckyFactor>>, gameHistory?: com.debertz.logic.data.models.table.history.GameHistory): com.debertz.logic.redux.actions.game.RoundEndedAction;
         get actionTag(): string;
     }
-    class PartyRestartedAction implements com.logic.domain.engine.definitions.Action {
+    class PartyRestartedAction implements com.logic.redux.store.definitions.Action {
         constructor(id: string, roundNumber: number);
         get id(): string;
         get partyNumber(): number;
@@ -760,7 +884,7 @@ export declare namespace com.debertz.logic.redux.actions.game {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
-        readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace com.debertz.logic.redux.actions.mechanic {
@@ -769,6 +893,41 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: com.logic.redux.actions.BufferedAction["__doNotUseOrImplementIt"];
     }
+    interface FirstMechanicAction extends com.logic.redux.store.definitions.Action {
+        readonly id: string;
+        readonly version: string;
+        readonly users: any/* kotlin.collections.List<com.logic.data.models.player.GameUserInfo> */;
+        readonly config: com.debertz.logic.data.models.table.config.Config;
+        readonly gameCreatorPlayerId: string;
+        readonly actionTag: string;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.debertz.logic.redux.actions.mechanic.FirstMechanicAction": unique symbol;
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
+    }
+    class StartGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.FirstMechanicAction {
+        constructor(config: com.debertz.logic.data.models.table.config.Config, id: string, version: string, gameCreatorPlayerId: string, users: any/* kotlin.collections.List<com.logic.data.models.player.GameUserInfo> */);
+        get config(): com.debertz.logic.data.models.table.config.Config;
+        get id(): string;
+        get version(): string;
+        get gameCreatorPlayerId(): string;
+        get users(): any/* kotlin.collections.List<com.logic.data.models.player.GameUserInfo> */;
+        copy(config?: com.debertz.logic.data.models.table.config.Config, id?: string, version?: string, gameCreatorPlayerId?: string, users?: any/* kotlin.collections.List<com.logic.data.models.player.GameUserInfo> */): com.debertz.logic.redux.actions.mechanic.StartGameMechanicAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+        readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.debertz.logic.redux.actions.mechanic.FirstMechanicAction["__doNotUseOrImplementIt"];
+    }
+    class StartNewGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction {
+        constructor(previousGameId: string, gameId: string);
+        get previousGameId(): string;
+        get gameId(): string;
+        copy(previousGameId?: string, gameId?: string): com.debertz.logic.redux.actions.mechanic.StartNewGameMechanicAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+    }
     class FinishingGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.TerminatedAction {
         constructor(reason: com.logic.data.models.TerminationGameReason);
         get reason(): com.logic.data.models.TerminationGameReason;
@@ -790,16 +949,16 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         notValidateWhenFinishing(): boolean;
         readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.debertz.logic.redux.actions.mechanic.TerminatedAction["__doNotUseOrImplementIt"];
     }
-    interface NavigationMechanicAction extends com.logic.domain.engine.definitions.Action {
+    interface NavigationMechanicAction extends com.logic.redux.store.definitions.Action {
         readonly sceneId: string;
         readonly actId: Nullable<string>;
         readonly actPayload: Nullable<com.debertz.logic.data.models.scenes.ActData>;
         readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction": unique symbol;
-        } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
-    class SceneMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction, com.logic.domain.engine.definitions.Action, com.logic.redux.actions.ReleaseBufferTriggerAction, com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished/*, com.debertz.logic.redux.actions.mechanic.NextPlayerTurnAction */ {
+    class SceneMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction, com.logic.redux.store.definitions.Action, com.logic.redux.actions.ReleaseBufferTriggerAction, com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished/*, com.debertz.logic.redux.actions.mechanic.NextPlayerTurnAction */ {
         constructor(sceneId: string, actId?: Nullable<string>, scenePayload?: Nullable<com.debertz.logic.data.models.scenes.SceneData>, actPayload?: Nullable<com.debertz.logic.data.models.scenes.ActData>);
         get sceneId(): string;
         get actId(): Nullable<string>;
@@ -812,14 +971,14 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
-        readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction["__doNotUseOrImplementIt"] & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.ReleaseBufferTriggerAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.ReleaseBufferTriggerAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
     }
-    interface TerminatedAction extends com.logic.domain.engine.definitions.Action {
+    interface TerminatedAction extends com.logic.redux.store.definitions.Action {
         readonly reason: com.logic.data.models.TerminationGameReason;
         readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.debertz.logic.redux.actions.mechanic.TerminatedAction": unique symbol;
-        } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
     class PlayerConnectionChangedMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished {
         constructor(playerId: string, state: com.logic.data.models.player.PlayerConnectionState, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>);
@@ -851,6 +1010,8 @@ export declare interface ParserHelper {
     decodeFromClientEvent(fromPlayerId: string, json: string): com.debertz.logic.redux.actions.client.from.FromClientAction;
     encodeToClientEvent(action: com.debertz.logic.redux.actions.client.to.ToClientAction): string;
     decodeToClientEventToMechanicAction(playerId: string, engine: com.debertz.logic.GameStoreContract, json: string): com.debertz.logic.redux.actions.mechanic.MechanicAction;
+    encodeGameRound(round: com.debertz.logic.data.models.table.history.RoundHistory): string;
+    encodeGameRoundItems(round: com.debertz.logic.data.models.table.history.RoundHistory): string;
     readonly __doNotUseOrImplementIt: {
         readonly ParserHelper: unique symbol;
     };
@@ -944,6 +1105,7 @@ export declare namespace com.debertz.logic.client.domain.mechanic {
         tutorialPassed(skipped: boolean): void;
         playerExit(): void;
         error(error: Nullable<com.debertz.logic.client.redux.state.ErrorState>): void;
+        observeGameHistoryEvents(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.vm.HistoryViewModel> */;
         readonly id: string;
         readonly table: com.debertz.logic.data.models.table.DebertzTable;
         readonly isTableExists: boolean;
@@ -987,6 +1149,7 @@ export declare namespace com.debertz.logic.client.domain.mechanic.online {
         tutorialPassed(skipped: boolean): void;
         playerExit(): void;
         error(error: Nullable<com.debertz.logic.client.redux.state.ErrorState>): void;
+        observeGameHistoryEvents(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.vm.HistoryViewModel> */;
         readonly id: string;
         readonly table: com.debertz.logic.data.models.table.DebertzTable;
         readonly isTableExists: boolean;
@@ -1009,14 +1172,14 @@ export declare namespace com.debertz.logic.client.redux.state {
     }
 }
 export declare namespace com.debertz.logic.client.utils {
-    interface ShowClientErrorLoggerOutput extends com.logic.utils.logger.outputs.LoggerOutput {
+    interface ShowErrorLoggerOutput extends com.logic.utils.logger.outputs.LoggerOutput {
         skipWarnings: boolean;
         gameClientProvider: Nullable<() => any/* com.debertz.logic.client.GameClient */>;
         d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
         e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
         w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.client.utils.ShowClientErrorLoggerOutput": unique symbol;
+            readonly "com.debertz.logic.client.utils.ShowErrorLoggerOutput": unique symbol;
         } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"];
     }
 }
@@ -1024,7 +1187,7 @@ export declare interface GameClientEngineController {
     readonly parser: ParserHelper;
     setEnableLogger(enabled: boolean): void;
     createOnlineGameEngine(currentPlayerId: string): com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic;
-    createOnlineGameEngineWithLogic(currentPlayerId: string, reducers?: Array<(p0: any/* com.debertz.logic.redux.AppState */, p1: any) => any/* com.debertz.logic.redux.AppState */>, middlewares?: Array<(p0: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, p1: (p0: com.logic.domain.engine.definitions.Action) => void, p2: any) => void>, isAutoStepCurrentPlayer?: boolean, botExitsWhenNGameNumberIsFinished?: Nullable<number>): com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic;
+    createOnlineGameEngineWithLogic(currentPlayerId: string, reducers?: Array<(p0: any/* com.debertz.logic.redux.AppState */, p1: any) => any/* com.debertz.logic.redux.AppState */>, middlewares?: Array<(p0: com.logic.redux.store.definitions.Store<any/* com.debertz.logic.redux.AppState */>, p1: (p0: com.logic.redux.store.definitions.Action) => void, p2: any) => void>, isAutoStepCurrentPlayer?: boolean, botExitsWhenNGameNumberIsFinished?: Nullable<number>): com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic;
     readonly __doNotUseOrImplementIt: {
         readonly GameClientEngineController: unique symbol;
     };