client_plugin_logic_deb 1.5.20 → 1.8.208

package/Logic_Debertz-client_plugin.d.ts

@@ -1,15 +1,310 @@
 type Nullable<T> = T | null | undefined
+export declare namespace kotlin.collections {
+    interface KtList<E> /* extends kotlin.collections.Collection<E> */ {
+        asJsReadonlyArrayView(): ReadonlyArray<E>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "kotlin.collections.KtList": unique symbol;
+        };
+    }
+    interface KtSet<E> /* extends kotlin.collections.Collection<E> */ {
+        asJsReadonlySetView(): ReadonlySet<E>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "kotlin.collections.KtSet": unique symbol;
+        };
+    }
+    interface KtMap<K, V> {
+        asJsReadonlyMapView(): ReadonlyMap<K, V>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "kotlin.collections.KtMap": unique symbol;
+        };
+    }
+}
+export declare namespace games.raspberry.logger {
+    interface LoggerEnabledTrigger extends games.raspberry.logger.RaspberryLogger {
+        enabled: boolean;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.raspberry.logger.LoggerEnabledTrigger": unique symbol;
+        } & games.raspberry.logger.RaspberryLogger["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.raspberry.logger {
+    interface LoggerPayload {
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.raspberry.logger.LoggerPayload": unique symbol;
+        };
+    }
+}
+export declare namespace games.raspberry.logger {
+    interface RaspberryLogger extends games.raspberry.logger.output.LoggerOutput {
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.raspberry.logger.RaspberryLogger": unique symbol;
+        } & games.raspberry.logger.output.LoggerOutput["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.raspberry.logger.output {
+    interface LoggerOutput {
+        d(tag: Nullable<string> | undefined, 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?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
+        v(tag?: Nullable<string>, message?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
+        i(tag: Nullable<string> | undefined, message: string, payload?: Nullable<any>): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.raspberry.logger.output.LoggerOutput": unique symbol;
+        };
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class CardDecksRequestUserData {
+        constructor(id: string, count: number);
+        get id(): string;
+        get count(): number;
+        copy(id?: string, count?: number): games.raspberry.card_game.random.data.models.CardDecksRequestUserData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    class CardDeckRequestUserData {
+        constructor(players: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.UserInfoData>, gameId: string);
+        get players(): kotlin.collections.KtList<games.raspberry.card_game.random.data.models.UserInfoData>;
+        get gameId(): string;
+        copy(players?: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.UserInfoData>, gameId?: string): games.raspberry.card_game.random.data.models.CardDeckRequestUserData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    class UserInfoData {
+        constructor(id: string, name: string);
+        get id(): string;
+        get name(): string;
+        copy(id?: string, name?: string): games.raspberry.card_game.random.data.models.UserInfoData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class GameCardDecksRecord {
+        constructor(id: string, signature: Nullable<string>, userData: games.raspberry.card_game.random.data.models.CardDeckRequestUserData, rounds?: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.GameCardDeckData>);
+        get id(): string;
+        get signature(): Nullable<string>;
+        get userData(): games.raspberry.card_game.random.data.models.CardDeckRequestUserData;
+        get rounds(): kotlin.collections.KtList<games.raspberry.card_game.random.data.models.GameCardDeckData>;
+        copy(id?: string, signature?: Nullable<string>, userData?: games.raspberry.card_game.random.data.models.CardDeckRequestUserData, rounds?: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.GameCardDeckData>): games.raspberry.card_game.random.data.models.GameCardDecksRecord;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            firstRound(id: string, signature: Nullable<string>, newCardDeckData: games.raspberry.card_game.random.data.models.GameCardDeckData, userData: games.raspberry.card_game.random.data.models.CardDeckRequestUserData): games.raspberry.card_game.random.data.models.GameCardDecksRecord;
+            newRound(gameCardDecksRecord: games.raspberry.card_game.random.data.models.GameCardDecksRecord, newCardDeckData: games.raspberry.card_game.random.data.models.GameCardDeckData): games.raspberry.card_game.random.data.models.GameCardDecksRecord;
+        };
+    }
+    class GameCardDeckData {
+        constructor(cardDeckIndex: number, cards: kotlin.collections.KtList<number>);
+        get cardDeckIndex(): number;
+        get cards(): kotlin.collections.KtList<number>;
+        copy(cardDeckIndex?: number, cards?: kotlin.collections.KtList<number>): games.raspberry.card_game.random.data.models.GameCardDeckData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class HttpConfig {
+        constructor(baseUrl: string, timeoutMillis?: number);
+        get baseUrl(): string;
+        get timeoutMillis(): number;
+        copy(baseUrl?: string, timeoutMillis?: number): games.raspberry.card_game.random.data.models.HttpConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class RandomOrgConfig {
+        constructor(apiKey?: string, poolSize?: number, thresholdForUsedPool?: number, httpConfig?: games.raspberry.card_game.random.data.models.HttpConfig);
+        get apiKey(): string;
+        get poolSize(): number;
+        get thresholdForUsedPool(): number;
+        get httpConfig(): games.raspberry.card_game.random.data.models.HttpConfig;
+        copy(apiKey?: string, poolSize?: number, thresholdForUsedPool?: number, httpConfig?: games.raspberry.card_game.random.data.models.HttpConfig): games.raspberry.card_game.random.data.models.RandomOrgConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.providers {
+    class PoolParams {
+        constructor(poolSize?: number, thresholdForUsedPool?: number, requestDurationWarn?: number, failedRequestAttempts?: number, failedAttemptCooldown?: any/* kotlin.time.Duration */);
+        get poolSize(): number;
+        get thresholdForUsedPool(): number;
+        get requestDurationWarn(): number;
+        get failedRequestAttempts(): number;
+        get failedAttemptCooldown(): any/* kotlin.time.Duration */;
+        copy(poolSize?: number, thresholdForUsedPool?: number, requestDurationWarn?: number, failedRequestAttempts?: number, failedAttemptCooldown?: any/* kotlin.time.Duration */): games.raspberry.card_game.random.data.providers.PoolParams;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace io.raspberryapps.cardgame.core {
+    const CoreConfig: {
+        get version(): string;
+    };
+}
 export declare namespace com.logic {
     const GameEngineConfig: {
         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;
+        get requireDirectoryPath(): 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;
+        static get Companion(): {
+            getClientEngineTestMode(fileLogsEnabled: boolean, logsDirectoryPath: string, fileNameFormat?: string): com.logic.data.models.CoreConfig;
+            formatter(segment: string, gameId: string, roomId: string, userId: string): string;
+        };
+    }
+}
 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 playerId(): string;
+        get tag(): Nullable<string>;
+        get connectionState(): com.logic.data.models.player.PlayerConnectionState;
+        copy(playerId?: string, tag?: Nullable<string>): com.logic.data.models.PlayerLostConnectionReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.FinishPlayerReason["__doNotUseOrImplementIt"];
+    }
+    class PlayerTimeoutReason extends com.logic.data.models.TerminationGameReason implements com.logic.data.models.FinishPlayerReason {
+        constructor(playerId: string, tag: Nullable<string>);
+        get playerId(): string;
+        get tag(): Nullable<string>;
+        get connectionState(): com.logic.data.models.player.PlayerConnectionState;
+        copy(playerId?: string, tag?: Nullable<string>): com.logic.data.models.PlayerTimeoutReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.FinishPlayerReason["__doNotUseOrImplementIt"];
+    }
+    class PlayerExitReason extends com.logic.data.models.TerminationGameReason implements com.logic.data.models.FinishPlayerReason {
+        constructor(playerId: string);
+        get playerId(): string;
+        get connectionState(): com.logic.data.models.player.PlayerConnectionState;
+        copy(playerId?: string): com.logic.data.models.PlayerExitReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.FinishPlayerReason["__doNotUseOrImplementIt"];
+    }
+    interface FinishPlayerReason {
+        readonly playerId: string;
+        readonly connectionState: com.logic.data.models.player.PlayerConnectionState;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.data.models.FinishPlayerReason": unique symbol;
+        };
+    }
+    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;
+    }
+    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 FINISHED(): com.logic.data.models.GameFinishedReason.Reason & {
+                get name(): "FINISHED";
+                get ordinal(): 2;
+            };
+            static get NO_ACTIVE_PLAYERS(): com.logic.data.models.GameFinishedReason.Reason & {
+                get name(): "NO_ACTIVE_PLAYERS";
+                get ordinal(): 3;
+            };
+            static get GAME_NOT_EXISTS(): com.logic.data.models.GameFinishedReason.Reason & {
+                get name(): "GAME_NOT_EXISTS";
+                get ordinal(): 4;
+            };
+            get name(): "DEPLOY" | "PLAYER_DELETED" | "FINISHED" | "NO_ACTIVE_PLAYERS" | "GAME_NOT_EXISTS";
+            get ordinal(): 0 | 1 | 2 | 3 | 4;
+            static values(): Array<com.logic.data.models.GameFinishedReason.Reason>;
+            static valueOf(value: string): com.logic.data.models.GameFinishedReason.Reason;
+            static get Companion(): {
+            } & any/* kotlinx.serialization.internal.SerializerFactory */;
+        }
+    }
+    class GameErrorReason extends com.logic.data.models.TerminationGameReason {
+        constructor(reason: com.logic.data.models.GameErrorReason.Reason);
+        get reason(): com.logic.data.models.GameErrorReason.Reason;
+        copy(reason?: com.logic.data.models.GameErrorReason.Reason): com.logic.data.models.GameErrorReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    namespace GameErrorReason {
+        abstract class Reason {
+            private constructor();
+            static get SERVER_ERROR(): com.logic.data.models.GameErrorReason.Reason & {
+                get name(): "SERVER_ERROR";
+                get ordinal(): 0;
+            };
+            static get INTERNAL_ERROR(): com.logic.data.models.GameErrorReason.Reason & {
+                get name(): "INTERNAL_ERROR";
+                get ordinal(): 1;
+            };
+            static get GAME_NOT_EXISTS(): com.logic.data.models.GameErrorReason.Reason & {
+                get name(): "GAME_NOT_EXISTS";
+                get ordinal(): 2;
+            };
+            static get WRONG_PLAYER_TURN(): com.logic.data.models.GameErrorReason.Reason & {
+                get name(): "WRONG_PLAYER_TURN";
+                get ordinal(): 3;
+            };
+            static get PLAYER_DISCONNECTED(): com.logic.data.models.GameErrorReason.Reason & {
+                get name(): "PLAYER_DISCONNECTED";
+                get ordinal(): 4;
+            };
+            get name(): "SERVER_ERROR" | "INTERNAL_ERROR" | "GAME_NOT_EXISTS" | "WRONG_PLAYER_TURN" | "PLAYER_DISCONNECTED";
+            get ordinal(): 0 | 1 | 2 | 3 | 4;
+            static values(): Array<com.logic.data.models.GameErrorReason.Reason>;
+            static valueOf(value: string): com.logic.data.models.GameErrorReason.Reason;
+            static get Companion(): {
+            } & any/* kotlinx.serialization.internal.SerializerFactory */;
+        }
+    }
+    const WaitingForConnectionReason: {
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & com.logic.data.models.TerminationGameReason;
+    const ProcessingReason: {
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & com.logic.data.models.TerminationGameReason;
 }
 export declare namespace com.logic.data.models.player {
     class GameUserInfo implements com.logic.data.models.player.PlayerIdContract {
@@ -20,8 +315,8 @@ export declare namespace com.logic.data.models.player {
         get isBot(): boolean;
         get initialLuckyFactor(): Nullable<number>;
         get payload(): Nullable<any>;
-        copy(playerId?: string, name?: string, avatarUrl?: Nullable<string>, isBot?: boolean, initialLuckyFactor?: Nullable<number>, payload?: Nullable<any>): com.logic.data.models.player.GameUserInfo;
         toString(): string;
+        copy(playerId?: string, name?: string, avatarUrl?: Nullable<string>, isBot?: boolean, initialLuckyFactor?: Nullable<number>, payload?: Nullable<any>): com.logic.data.models.player.GameUserInfo;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
@@ -34,8 +329,8 @@ export declare namespace com.logic.data.models.player {
             readonly "com.logic.data.models.player.PlayerIdContract": unique symbol;
         };
     }
-    function getPlayer<T extends com.logic.data.models.player.PlayerIdContract>(_this_: any/* kotlin.collections.List<T> */, id: string): T;
-    function getPlayerIndex<T extends com.logic.data.models.player.PlayerIdContract>(_this_: any/* kotlin.collections.List<T> */, playerId: string): number;
+    function getPlayer<T extends com.logic.data.models.player.PlayerIdContract>(_this_: kotlin.collections.KtList<T>, id: string): T;
+    function getPlayerIndex<T extends com.logic.data.models.player.PlayerIdContract>(_this_: kotlin.collections.KtList<T>, playerId: string): number;
 }
 export declare namespace com.logic.data.models.player {
     abstract class PlayerConnectionState {
@@ -64,6 +359,8 @@ export declare namespace com.logic.data.models.player {
             get name(): "DELETED";
             get ordinal(): 5;
         };
+        get name(): "LIVE" | "TIMEOUT" | "LOST_CONNECTION" | "LEFT" | "DISCONNECTING" | "DELETED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
         get isLive(): boolean;
         get isTimeOut(): boolean;
         get isLostConnection(): boolean;
@@ -72,123 +369,29 @@ export declare namespace com.logic.data.models.player {
         get isDisconnecting(): boolean;
         get isNotAlive(): boolean;
         get isDisconnected(): boolean;
+        get isClientDisconnectReason(): boolean;
+        get isServerDisconnectReason(): boolean;
         static values(): Array<com.logic.data.models.player.PlayerConnectionState>;
         static valueOf(value: string): com.logic.data.models.player.PlayerConnectionState;
-        get name(): "LIVE" | "TIMEOUT" | "LOST_CONNECTION" | "LEFT" | "DISCONNECTING" | "DELETED";
-        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
-export declare namespace com.logic.data.models.player {
-    class PlayerLuckyFactor implements com.logic.data.models.player.PlayerIdContract {
-        constructor(playerId: string, factor: number, wasLiveDuringGame: boolean, liveDurationPercentage: Nullable<number>);
-        get playerId(): string;
-        get factor(): number;
-        get wasLiveDuringGame(): boolean;
-        get liveDurationPercentage(): Nullable<number>;
-        copy(playerId?: string, factor?: number, wasLiveDuringGame?: boolean, liveDurationPercentage?: Nullable<number>): com.logic.data.models.player.PlayerLuckyFactor;
-        toString(): string;
-        hashCode(): number;
-        equals(other: Nullable<any>): boolean;
-        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
-    }
-}
-export declare namespace com.logic.data.models.rules {
-    class Rules {
-        constructor(needToPutHigherTrump: boolean, distributePoints: boolean, protectBella: boolean, oneTryToProtectBella: boolean, enableFourSevensCombination: boolean, enableTrumpSevenCombination: boolean, enableTrumpSevenCombinationAfterDistribution: boolean, playerWhoChooseSuitGoFirst: boolean, winnerShuffleCards: boolean, playWithoutLiabilities: boolean, trumpCardGoToPlayerWhoShuffleCards: boolean, enableFineIfNoBribes: boolean, fineIfNoBribes: number, enableFineAfterThirdByte: boolean, checkTrumpCombination: boolean, checkOnlyTrumpDebertz: boolean, tenCardsInHand: boolean);
-        get needToPutHigherTrump(): boolean;
-        get distributePoints(): boolean;
-        get protectBella(): boolean;
-        get oneTryToProtectBella(): boolean;
-        get enableFourSevensCombination(): boolean;
-        get enableTrumpSevenCombination(): boolean;
-        get enableTrumpSevenCombinationAfterDistribution(): boolean;
-        get playerWhoChooseSuitGoFirst(): boolean;
-        get winnerShuffleCards(): boolean;
-        get playWithoutLiabilities(): boolean;
-        get trumpCardGoToPlayerWhoShuffleCards(): boolean;
-        get enableFineIfNoBribes(): boolean;
-        get fineIfNoBribes(): number;
-        get enableFineAfterThirdByte(): boolean;
-        get checkTrumpCombination(): boolean;
-        get checkOnlyTrumpDebertz(): boolean;
-        get tenCardsInHand(): boolean;
-        copy(needToPutHigherTrump?: boolean, distributePoints?: boolean, protectBella?: boolean, oneTryToProtectBella?: boolean, enableFourSevensCombination?: boolean, enableTrumpSevenCombination?: boolean, enableTrumpSevenCombinationAfterDistribution?: boolean, playerWhoChooseSuitGoFirst?: boolean, winnerShuffleCards?: boolean, playWithoutLiabilities?: boolean, trumpCardGoToPlayerWhoShuffleCards?: boolean, enableFineIfNoBribes?: boolean, fineIfNoBribes?: number, enableFineAfterThirdByte?: boolean, checkTrumpCombination?: boolean, checkOnlyTrumpDebertz?: boolean, tenCardsInHand?: boolean): com.logic.data.models.rules.Rules;
-        toString(): string;
-        hashCode(): number;
-        equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-            kharkiv(): com.logic.data.models.rules.Rules;
-            klabor(): com.logic.data.models.rules.Rules;
-            debertzCommon(): com.logic.data.models.rules.Rules;
-            belot(): com.logic.data.models.rules.Rules;
-            custom(): com.logic.data.models.rules.Rules;
-        };
-    }
-}
-export declare namespace com.logic.data.models.rules {
-    abstract class RulesSetType {
-        private constructor();
-        get value(): string;
-        static get belot(): com.logic.data.models.rules.RulesSetType & {
-            get name(): "belot";
-            get ordinal(): 0;
-        };
-        static get klabor(): com.logic.data.models.rules.RulesSetType & {
-            get name(): "klabor";
-            get ordinal(): 1;
-        };
-        static get debertzCommon(): com.logic.data.models.rules.RulesSetType & {
-            get name(): "debertzCommon";
-            get ordinal(): 2;
-        };
-        static get debertzKharkiv(): com.logic.data.models.rules.RulesSetType & {
-            get name(): "debertzKharkiv";
-            get ordinal(): 3;
-        };
-        static get custom(): com.logic.data.models.rules.RulesSetType & {
-            get name(): "custom";
-            get ordinal(): 4;
-        };
-        static values(): Array<com.logic.data.models.rules.RulesSetType>;
-        static valueOf(value: string): com.logic.data.models.rules.RulesSetType;
-        get name(): "belot" | "klabor" | "debertzCommon" | "debertzKharkiv" | "custom";
-        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.redux.actions {
-    interface BufferedAction extends com.logic.domain.engine.definitions.Action {
-        readonly actionTag: string;
+    interface BufferedAction extends com.logic.redux.store.definitions.Action {
         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 {
-        readonly actionTag: string;
+    interface IgnoreBufferForAction extends com.logic.redux.store.definitions.Action {
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.redux.actions.IgnoreBufferForAction": unique symbol;
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
+    }
+    interface ReleaseBufferTriggerAction extends com.logic.redux.store.definitions.Action {
         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 {
@@ -207,20 +410,23 @@ export declare namespace com.logic.redux.actions.validation {
         };
     }
 }
-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;
-        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
-        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+export declare namespace com.logic.redux.store.definitions {
+    interface Action {
+        readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.utils.logger.game.GameLogger": unique symbol;
-        } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"];
+            readonly "com.logic.redux.store.definitions.Action": unique symbol;
+        };
     }
 }
-export declare namespace com.logic.utils.logger.game {
-    interface LoggerPayload {
+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.utils.logger.game.LoggerPayload": unique symbol;
+            readonly "com.logic.redux.store.definitions.Store": unique symbol;
         };
     }
 }
@@ -239,53 +445,39 @@ export declare namespace com.logic.utils.logger.outputs {
             get name(): "WARN";
             get ordinal(): 2;
         };
+        static get VERBOSE(): com.logic.utils.logger.outputs.LogType & {
+            get name(): "VERBOSE";
+            get ordinal(): 3;
+        };
+        static get INFO(): com.logic.utils.logger.outputs.LogType & {
+            get name(): "INFO";
+            get ordinal(): 4;
+        };
+        get name(): "DEBUG" | "ERROR" | "WARN" | "VERBOSE" | "INFO";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
         static values(): Array<com.logic.utils.logger.outputs.LogType>;
         static valueOf(value: string): com.logic.utils.logger.outputs.LogType;
-        get name(): "DEBUG" | "ERROR" | "WARN";
-        get ordinal(): 0 | 1 | 2;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
 export declare namespace com.logic.utils.logger.outputs {
-    interface LoggerEnabledTrigger extends com.logic.utils.logger.game.GameLogger {
-        enabled: boolean;
-        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.logic.utils.logger.outputs.LoggerEnabledTrigger": unique symbol;
-        } & com.logic.utils.logger.game.GameLogger["__doNotUseOrImplementIt"];
-    }
-}
-export declare namespace com.logic.utils.logger.outputs {
-    interface LoggerOutput {
-        d(tag: Nullable<string> | undefined, message: string, payload?: Nullable<any>): void;
-        e(tag?: Nullable<string>, message?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
-        w(tag: Nullable<string> | undefined, message: string, payload?: Nullable<any>): void;
-        readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.utils.logger.outputs.LoggerOutput": unique symbol;
-        };
-    }
-}
-export declare namespace com.logic.utils.logger.outputs {
-    interface ObservableLoggerOutput extends com.logic.utils.logger.outputs.LoggerOutput, com.logic.utils.logger.outputs.LoggerEnabledTrigger {
+    interface ObservableLoggerOutput extends games.raspberry.logger.output.LoggerOutput, games.raspberry.logger.LoggerEnabledTrigger {
+        payloadToKeyMapper: (p0: Nullable<any>) => Nullable<string>;
         observe(types?: Array<com.logic.utils.logger.outputs.LogType>): any/* kotlinx.coroutines.flow.Flow<com.logic.utils.logger.outputs.LoggerOutputDataDto> */;
-        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;
-        enabled: boolean;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.utils.logger.outputs.ObservableLoggerOutput": unique symbol;
-        } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"] & com.logic.utils.logger.outputs.LoggerEnabledTrigger["__doNotUseOrImplementIt"];
+        } & games.raspberry.logger.output.LoggerOutput["__doNotUseOrImplementIt"] & games.raspberry.logger.LoggerEnabledTrigger["__doNotUseOrImplementIt"];
     }
     class LoggerOutputDataDto {
-        constructor(type: com.logic.utils.logger.outputs.LogType, tag: Nullable<string>, message: Nullable<string>, stackTrace: Nullable<string>);
+        constructor(type: com.logic.utils.logger.outputs.LogType, key: Nullable<string>, tag: Nullable<string>, message: Nullable<string>, stackTrace: Nullable<string>);
         get type(): com.logic.utils.logger.outputs.LogType;
+        get key(): Nullable<string>;
         get tag(): Nullable<string>;
         get message(): Nullable<string>;
         get stackTrace(): Nullable<string>;
-        copy(type?: com.logic.utils.logger.outputs.LogType, tag?: Nullable<string>, message?: Nullable<string>, stackTrace?: Nullable<string>): com.logic.utils.logger.outputs.LoggerOutputDataDto;
+        toMessageLog(): string;
+        copy(type?: com.logic.utils.logger.outputs.LogType, key?: Nullable<string>, tag?: Nullable<string>, message?: Nullable<string>, stackTrace?: Nullable<string>): com.logic.utils.logger.outputs.LoggerOutputDataDto;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -293,677 +485,1401 @@ export declare namespace com.logic.utils.logger.outputs {
         };
     }
 }
-export declare namespace com.debertz.logic {
+export declare namespace games.jass.logic {
     interface GameStoreContract {
         readonly id: string;
-        readonly table: com.debertz.logic.data.models.table.DebertzTable;
+        readonly table: games.jass.logic.data.models.table.JassTable;
         readonly isTableExists: boolean;
-        readonly gameLifecycleState: com.debertz.logic.data.models.GameLifecycleState;
+        readonly gameLifecycleState: games.jass.logic.data.models.GameLifecycleState;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.GameStoreContract": unique symbol;
+            readonly "games.jass.logic.GameStoreContract": unique symbol;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models {
+    class DealerConfig {
+        constructor(dealerStrategy?: games.jass.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean, cards?: Nullable<Array<number>>);
+        get dealerStrategy(): games.jass.logic.domain.interactors.dealer.DealerStrategy;
+        get isBotsAreHappy(): boolean;
+        get cards(): Nullable<Array<number>>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(dealerStrategy?: games.jass.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean, cards?: Nullable<Array<number>>): games.jass.logic.data.models.DealerConfig;
+        toString(): string;
+        static get Companion(): {
+            getFromServerConfig(dealerStrategy?: string, cardsJson?: Nullable<string>): games.jass.logic.data.models.DealerConfig;
+            fake(cards?: Array<number>): games.jass.logic.data.models.DealerConfig;
         };
     }
 }
-export declare namespace com.debertz.logic.data.models {
-    class BotReduxConfig {
+export declare namespace games.jass.logic.data.models {
+    class EngineBotConfig {
         constructor(botExitsWhenNGameNumberIsFinished?: Nullable<number>, autoStepLastCard?: boolean, simulateBotThinkingDelay?: boolean, isDelayForBot?: boolean);
         get botExitsWhenNGameNumberIsFinished(): Nullable<number>;
         get autoStepLastCard(): boolean;
         get simulateBotThinkingDelay(): boolean;
         get isDelayForBot(): boolean;
-        copy(botExitsWhenNGameNumberIsFinished?: Nullable<number>, autoStepLastCard?: boolean, simulateBotThinkingDelay?: boolean, isDelayForBot?: boolean): com.debertz.logic.data.models.BotReduxConfig;
+        copy(botExitsWhenNGameNumberIsFinished?: Nullable<number>, autoStepLastCard?: boolean, simulateBotThinkingDelay?: boolean, isDelayForBot?: boolean): games.jass.logic.data.models.EngineBotConfig;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
 }
-export declare namespace com.debertz.logic.data.models {
+export declare namespace games.jass.logic.data.models {
+    class EngineLogicConfig {
+        constructor(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, gameHistoryAnalytics?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number, openRoomIfFinished?: boolean, minPlayersToOpenRoom?: number);
+        get supportBackwardActions(): boolean;
+        get validateTestMode(): boolean;
+        get verboseGameHistory(): boolean;
+        get gameHistoryMetadata(): boolean;
+        get validateFromClientActionTags(): boolean;
+        get playerTimeoutFactorToFinishStep(): number;
+        get openRoomIfFinished(): boolean;
+        get minPlayersToOpenRoom(): number;
+        copy(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, gameHistoryAnalytics?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number, openRoomIfFinished?: boolean, minPlayersToOpenRoom?: number): games.jass.logic.data.models.EngineLogicConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            getClientEngineTestMode(): games.jass.logic.data.models.EngineLogicConfig;
+            getServerEngineMode(isProduction: boolean, supportBackwardActions?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number): games.jass.logic.data.models.EngineLogicConfig;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models {
     abstract class GameLifecycleState {
         private constructor();
-        static get CREATED(): com.debertz.logic.data.models.GameLifecycleState & {
+        static get CREATED(): games.jass.logic.data.models.GameLifecycleState & {
             get name(): "CREATED";
             get ordinal(): 0;
         };
-        static get CREATING(): com.debertz.logic.data.models.GameLifecycleState & {
+        static get CREATING(): games.jass.logic.data.models.GameLifecycleState & {
             get name(): "CREATING";
             get ordinal(): 1;
         };
-        static get FINISHING(): com.debertz.logic.data.models.GameLifecycleState & {
+        static get FINISHING(): games.jass.logic.data.models.GameLifecycleState & {
             get name(): "FINISHING";
             get ordinal(): 2;
         };
-        static get FINISHED(): com.debertz.logic.data.models.GameLifecycleState & {
+        static get FINISHED(): games.jass.logic.data.models.GameLifecycleState & {
             get name(): "FINISHED";
             get ordinal(): 3;
         };
-        static values(): Array<com.debertz.logic.data.models.GameLifecycleState>;
-        static valueOf(value: string): com.debertz.logic.data.models.GameLifecycleState;
         get name(): "CREATED" | "CREATING" | "FINISHING" | "FINISHED";
         get ordinal(): 0 | 1 | 2 | 3;
+        static values(): Array<games.jass.logic.data.models.GameLifecycleState>;
+        static valueOf(value: string): games.jass.logic.data.models.GameLifecycleState;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
-export declare namespace com.debertz.logic.data.models {
-    class LogicReduxConfig {
-        constructor(supportBackwardActions?: boolean, supportPlayerTurnActions?: boolean, validateTestMode?: boolean, cards?: Nullable<Array<number>>, dealer?: com.debertz.logic.data.models.DealerConfig);
-        get supportBackwardActions(): boolean;
-        get supportPlayerTurnActions(): boolean;
-        get validateTestMode(): boolean;
-        get cards(): Nullable<Array<number>>;
-        get dealer(): com.debertz.logic.data.models.DealerConfig;
+export declare namespace games.jass.logic.data.models {
+    class GameSessionAnalytics {
+        constructor(duration: any/* kotlin.time.Duration */, gamesCount: number, roundsCountTotal: number, handsCount: number, playerAnalytics: Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>);
+        get duration(): any/* kotlin.time.Duration */;
+        get gamesCount(): number;
+        get roundsCountTotal(): number;
+        get handsCount(): number;
+        get playerAnalytics(): Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>;
+        get allCombinationCounts(): Array<games.jass.logic.data.models.CombinationPair>;
+        get allCombinationsAnalytics(): games.jass.logic.data.models.player.analytics.CombinationsAnalytics;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        copy(supportBackwardActions?: boolean, supportPlayerTurnActions?: boolean, validateTestMode?: boolean, cards?: Nullable<Array<number>>, dealer?: com.debertz.logic.data.models.DealerConfig): com.debertz.logic.data.models.LogicReduxConfig;
         toString(): string;
+        copy(duration?: any/* kotlin.time.Duration */, gamesCount?: number, roundsCountTotal?: number, handsCount?: number, playerAnalytics?: Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>): games.jass.logic.data.models.GameSessionAnalytics;
     }
-    class DealerConfig {
-        constructor(dealerStrategy?: com.debertz.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean);
-        get dealerStrategy(): com.debertz.logic.domain.interactors.dealer.DealerStrategy;
-        get isBotsAreHappy(): boolean;
-        copy(dealerStrategy?: com.debertz.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean): com.debertz.logic.data.models.DealerConfig;
+    class CombinationPair {
+        constructor(type: games.jass.logic.data.models.table.combinations.CombinationType, count: number);
+        get type(): games.jass.logic.data.models.table.combinations.CombinationType;
+        get count(): number;
+        copy(type?: games.jass.logic.data.models.table.combinations.CombinationType, count?: number): games.jass.logic.data.models.CombinationPair;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.config {
+    class ServerReduxConfig {
+        constructor(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsPeriod?: number);
+        get finishGameIfAllBots(): boolean;
+        get waitForPlayerToReconnect(): boolean;
+        get waitForPlayerToReconnectTimeOutMillis(): number;
+        get closeIfBotsAtFinish(): boolean;
+        get botReplacesPlayerAfterTimeout(): boolean;
+        get enabledCombinedEvents(): boolean;
+        get delayToAskBotMillis(): number;
+        get combinedEventsPeriod(): number;
+        copy(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsPeriod?: number): games.jass.logic.data.models.config.ServerReduxConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            get DELAY_TO_BUFFER_EVENTS_MILLIS(): number;
+            getServerEngineMode(finishGameIfAllBots: boolean, botReplacesPlayerAfterTimeout: boolean, closeIfBotsAtFinish: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number): games.jass.logic.data.models.config.ServerReduxConfig;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.dealer {
+    class RandomData {
+        constructor(signature: Nullable<string>, id: string, indexes: kotlin.collections.KtList<number>, provider: games.jass.logic.domain.interactors.dealer.DealerStrategy);
+        get signature(): Nullable<string>;
+        get id(): string;
+        get indexes(): kotlin.collections.KtList<number>;
+        get provider(): games.jass.logic.domain.interactors.dealer.DealerStrategy;
+        copy(signature?: Nullable<string>, id?: string, indexes?: kotlin.collections.KtList<number>, provider?: games.jass.logic.domain.interactors.dealer.DealerStrategy): games.jass.logic.data.models.dealer.RandomData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.messages.combinatios {
+    abstract class CombinationReason /* implements kotlin.Comparable<games.jass.logic.data.models.messages.combinatios.CombinationReason> */ {
+        private constructor();
+        static get WIN_SINGLE_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_SINGLE_COMBINATION";
+            get ordinal(): 0;
+        };
+        static get WIN_HIGHER_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_HIGHER_COMBINATION";
+            get ordinal(): 1;
+        };
+        static get WIN_HIGHER_CARD_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_HIGHER_CARD_COMBINATION";
+            get ordinal(): 2;
+        };
+        static get WIN_TRUMP_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_TRUMP_COMBINATION";
+            get ordinal(): 3;
+        };
+        static get WIN_HIGHER_PLAYER_NUMBER_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_HIGHER_PLAYER_NUMBER_COMBINATION";
+            get ordinal(): 4;
+        };
+        static get WIN_PARTNER_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_PARTNER_COMBINATION";
+            get ordinal(): 5;
+        };
+        static get REJECTED_NOT_TRUMP_SEVEN_IN_ROW_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "REJECTED_NOT_TRUMP_SEVEN_IN_ROW_COMBINATION";
+            get ordinal(): 6;
+        };
+        get name(): "WIN_SINGLE_COMBINATION" | "WIN_HIGHER_COMBINATION" | "WIN_HIGHER_CARD_COMBINATION" | "WIN_TRUMP_COMBINATION" | "WIN_HIGHER_PLAYER_NUMBER_COMBINATION" | "WIN_PARTNER_COMBINATION" | "REJECTED_NOT_TRUMP_SEVEN_IN_ROW_COMBINATION";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        static values(): Array<games.jass.logic.data.models.messages.combinatios.CombinationReason>;
+        static valueOf(value: string): games.jass.logic.data.models.messages.combinatios.CombinationReason;
+    }
+}
+export declare namespace games.jass.logic.data.models.player {
+    class UserProfilePayload {
+        constructor(socketId?: Nullable<string>, rating?: Nullable<number>, playedGamesCount?: number);
+        get socketId(): Nullable<string>;
+        get rating(): Nullable<number>;
+        get playedGamesCount(): number;
+        copy(socketId?: Nullable<string>, rating?: Nullable<number>, playedGamesCount?: number): games.jass.logic.data.models.player.UserProfilePayload;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.achievements {
+    class Achievements {
+        constructor(oldRating: number, newRating: number);
+        get oldRating(): number;
+        get newRating(): number;
+        copy(oldRating?: number, newRating?: number): games.jass.logic.data.models.player.achievements.Achievements;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.achievements {
+    class PlayerAchievements implements com.logic.data.models.player.PlayerIdContract {
+        constructor(playerId: string, oldRating: number, newRating: number);
+        get playerId(): string;
+        get oldRating(): number;
+        get newRating(): number;
+        copy(playerId?: string, oldRating?: number, newRating?: number): games.jass.logic.data.models.player.achievements.PlayerAchievements;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.player.analytics {
+    class CombinationsAnalytics {
+        constructor(combinations: Array<games.jass.logic.data.models.player.analytics.CombinationAnalytics>);
+        get combinations(): Array<games.jass.logic.data.models.player.analytics.CombinationAnalytics>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(combinations?: Array<games.jass.logic.data.models.player.analytics.CombinationAnalytics>): games.jass.logic.data.models.player.analytics.CombinationsAnalytics;
+        toString(): string;
+    }
+    class CombinationAnalytics {
+        constructor(type: games.jass.logic.data.models.table.combinations.CombinationType, count: number, acceptedCounts: number);
+        get type(): games.jass.logic.data.models.table.combinations.CombinationType;
+        get count(): number;
+        get acceptedCounts(): number;
+        copy(type?: games.jass.logic.data.models.table.combinations.CombinationType, count?: number, acceptedCounts?: number): games.jass.logic.data.models.player.analytics.CombinationAnalytics;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.analytics {
+    class PlayerAnalytics implements com.logic.data.models.player.PlayerIdContract {
+        constructor(playerId: string, factor: number, wasLiveDuringGame: boolean, liveDurationPercentage: Nullable<number>, combinationRecords: kotlin.collections.KtList<games.jass.logic.data.models.player.hand.CombinationRecord>);
+        get playerId(): string;
+        get factor(): number;
+        get wasLiveDuringGame(): boolean;
+        get liveDurationPercentage(): Nullable<number>;
+        get combinationRecords(): kotlin.collections.KtList<games.jass.logic.data.models.player.hand.CombinationRecord>;
+        get combinationCounts(): kotlin.collections.KtMap<games.jass.logic.data.models.table.combinations.CombinationType, number>;
+        get combinationsAnalytics(): games.jass.logic.data.models.player.analytics.CombinationsAnalytics;
+        toString(): string;
+        copy(playerId?: string, factor?: number, wasLiveDuringGame?: boolean, liveDurationPercentage?: Nullable<number>, combinationRecords?: kotlin.collections.KtList<games.jass.logic.data.models.player.hand.CombinationRecord>): games.jass.logic.data.models.player.analytics.PlayerAnalytics;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.player.analytics {
+    class PlayerHistoryAnalytics /* implements games.jass.logic.data.models.table.history.PlayerHistoryItem */ {
+        constructor(playerId: string, liveDurationPercentage: Nullable<number>, combinations: Nullable<kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.CombinationAnalytics>>, achievements: Nullable<games.jass.logic.data.models.player.achievements.Achievements>);
+        get liveDurationPercentage(): Nullable<number>;
+        get combinations(): Nullable<kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.CombinationAnalytics>>;
+        get achievements(): Nullable<games.jass.logic.data.models.player.achievements.Achievements>;
+        copy(playerId?: string, liveDurationPercentage?: Nullable<number>, combinations?: Nullable<kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.CombinationAnalytics>>, achievements?: Nullable<games.jass.logic.data.models.player.achievements.Achievements>): games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.bids {
+    abstract class BidType {
+        private constructor();
+        static get POINTS(): games.jass.logic.data.models.player.bids.BidType & {
+            get name(): "POINTS";
+            get ordinal(): 0;
+        };
+        static get CAPOT(): games.jass.logic.data.models.player.bids.BidType & {
+            get name(): "CAPOT";
+            get ordinal(): 1;
+        };
+        static get COINCHE(): games.jass.logic.data.models.player.bids.BidType & {
+            get name(): "COINCHE";
+            get ordinal(): 2;
+        };
+        static get GENERAL(): games.jass.logic.data.models.player.bids.BidType & {
+            get name(): "GENERAL";
+            get ordinal(): 3;
+        };
+        static get SURCOINCHE(): games.jass.logic.data.models.player.bids.BidType & {
+            get name(): "SURCOINCHE";
+            get ordinal(): 4;
+        };
+        get name(): "POINTS" | "CAPOT" | "COINCHE" | "GENERAL" | "SURCOINCHE";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
+        static values(): Array<games.jass.logic.data.models.player.bids.BidType>;
+        static valueOf(value: string): games.jass.logic.data.models.player.bids.BidType;
+        static get Companion(): {
+            get belotBalgarian(): Array<games.jass.logic.data.models.player.bids.BidType>;
+            get coinche(): Array<games.jass.logic.data.models.player.bids.BidType>;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.hand {
+    class CombinationRecord {
+        constructor(id: string, type: games.jass.logic.data.models.table.combinations.CombinationType, state: games.jass.logic.data.models.table.combinations.CombinationState, value: number);
+        get id(): string;
+        get type(): games.jass.logic.data.models.table.combinations.CombinationType;
+        get state(): games.jass.logic.data.models.table.combinations.CombinationState;
+        get value(): number;
+        get isAccepted(): boolean;
+        copy(id?: string, type?: games.jass.logic.data.models.table.combinations.CombinationType, state?: games.jass.logic.data.models.table.combinations.CombinationState, value?: number): games.jass.logic.data.models.player.hand.CombinationRecord;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
 }
-export declare namespace com.debertz.logic.data.models.scenes {
+export declare namespace games.jass.logic.data.models.player.state {
+    abstract class RoundContractState {
+        private constructor();
+        static get FAILED(): games.jass.logic.data.models.player.state.RoundContractState & {
+            get name(): "FAILED";
+            get ordinal(): 0;
+        };
+        static get FULFILLED(): games.jass.logic.data.models.player.state.RoundContractState & {
+            get name(): "FULFILLED";
+            get ordinal(): 1;
+        };
+        static get CONTROVERSIAL(): games.jass.logic.data.models.player.state.RoundContractState & {
+            get name(): "CONTROVERSIAL";
+            get ordinal(): 2;
+        };
+        get name(): "FAILED" | "FULFILLED" | "CONTROVERSIAL";
+        get ordinal(): 0 | 1 | 2;
+        get isFailed(): boolean;
+        get isFulfilled(): boolean;
+        get isControversial(): boolean;
+        static values(): Array<games.jass.logic.data.models.player.state.RoundContractState>;
+        static valueOf(value: string): games.jass.logic.data.models.player.state.RoundContractState;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.state {
+    abstract class RoundContractType {
+        private constructor();
+        static get TRUMP_TAKEN(): games.jass.logic.data.models.player.state.RoundContractType & {
+            get name(): "TRUMP_TAKEN";
+            get ordinal(): 0;
+        };
+        static get TRUMP_SELECTED(): games.jass.logic.data.models.player.state.RoundContractType & {
+            get name(): "TRUMP_SELECTED";
+            get ordinal(): 1;
+        };
+        static get NO_TRUMPS(): games.jass.logic.data.models.player.state.RoundContractType & {
+            get name(): "NO_TRUMPS";
+            get ordinal(): 2;
+        };
+        static get ALL_TRUMPS(): games.jass.logic.data.models.player.state.RoundContractType & {
+            get name(): "ALL_TRUMPS";
+            get ordinal(): 3;
+        };
+        get name(): "TRUMP_TAKEN" | "TRUMP_SELECTED" | "NO_TRUMPS" | "ALL_TRUMPS";
+        get ordinal(): 0 | 1 | 2 | 3;
+        static values(): Array<games.jass.logic.data.models.player.state.RoundContractType>;
+        static valueOf(value: string): games.jass.logic.data.models.player.state.RoundContractType;
+        static get Companion(): {
+            get debertzContractTypes(): kotlin.collections.KtList<games.jass.logic.data.models.player.state.RoundContractType>;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.rules {
+    class Rules {
+        constructor(needToPutHigherTrump: boolean, playerWhoChooseSuitGoFirst: boolean, winnerShuffleCards: boolean, playWithoutLiabilities: boolean, trumpCardGoToPlayerWhoShuffleCards: boolean, dealerInitialCardsCount: number, dealerFinalCardsCount: number, dealerCounterClockwise: boolean, contractTypes: Array<games.jass.logic.data.models.player.state.RoundContractType>, bidTypes: Array<games.jass.logic.data.models.player.bids.BidType>, combinationsWithFirstCard: Array<games.jass.logic.data.models.table.combinations.CombinationType>, protectBella: boolean, oneTryToProtectBella: boolean, enableFourSevensCombination: boolean, enableTrumpSevenCombination: boolean, enableTrumpSevenCombinationAfterDistribution: boolean, checkTrumpCombination: boolean, checkOnlyTrumpDebertz: boolean, distributePoints: boolean, enableFineAfterThirdFailedContract: boolean, fineAfterThirdFailedContract: number, enableFineIfNoBribes: boolean, fineIfNoBribes: number);
+        get needToPutHigherTrump(): boolean;
+        get playerWhoChooseSuitGoFirst(): boolean;
+        get winnerShuffleCards(): boolean;
+        get playWithoutLiabilities(): boolean;
+        get trumpCardGoToPlayerWhoShuffleCards(): boolean;
+        get dealerInitialCardsCount(): number;
+        get dealerFinalCardsCount(): number;
+        get dealerCounterClockwise(): boolean;
+        get contractTypes(): Array<games.jass.logic.data.models.player.state.RoundContractType>;
+        get bidTypes(): Array<games.jass.logic.data.models.player.bids.BidType>;
+        get combinationsWithFirstCard(): Array<games.jass.logic.data.models.table.combinations.CombinationType>;
+        get protectBella(): boolean;
+        get oneTryToProtectBella(): boolean;
+        get enableFourSevensCombination(): boolean;
+        get enableTrumpSevenCombination(): boolean;
+        get enableTrumpSevenCombinationAfterDistribution(): boolean;
+        get checkTrumpCombination(): boolean;
+        get checkOnlyTrumpDebertz(): boolean;
+        get distributePoints(): boolean;
+        get enableFineAfterThirdByte(): boolean;
+        get fineAfterThirdFailedContract(): number;
+        get enableFineIfNoBribes(): boolean;
+        get fineIfNoBribes(): number;
+        toString(): string;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(needToPutHigherTrump?: boolean, playerWhoChooseSuitGoFirst?: boolean, winnerShuffleCards?: boolean, playWithoutLiabilities?: boolean, trumpCardGoToPlayerWhoShuffleCards?: boolean, dealerInitialCardsCount?: number, dealerFinalCardsCount?: number, dealerCounterClockwise?: boolean, contractTypes?: Array<games.jass.logic.data.models.player.state.RoundContractType>, bidTypes?: Array<games.jass.logic.data.models.player.bids.BidType>, combinationsWithFirstCard?: Array<games.jass.logic.data.models.table.combinations.CombinationType>, protectBella?: boolean, oneTryToProtectBella?: boolean, enableFourSevensCombination?: boolean, enableTrumpSevenCombination?: boolean, enableTrumpSevenCombinationAfterDistribution?: boolean, checkTrumpCombination?: boolean, checkOnlyTrumpDebertz?: boolean, distributePoints?: boolean, enableFineAfterThirdFailedContract?: boolean, fineAfterThirdFailedContract?: number, enableFineIfNoBribes?: boolean, fineIfNoBribes?: number): games.jass.logic.data.models.rules.Rules;
+        static get Companion(): {
+            get HAND_CARDS_INITIAL(): number;
+            get HAND_CARDS_FINAL(): number;
+            kharkiv(): games.jass.logic.data.models.rules.Rules;
+            saltivka(): games.jass.logic.data.models.rules.Rules;
+            klabor(): games.jass.logic.data.models.rules.Rules;
+            belotBulgarian(): games.jass.logic.data.models.rules.Rules;
+            debertzCommon(): games.jass.logic.data.models.rules.Rules;
+            belot(): games.jass.logic.data.models.rules.Rules;
+            custom(): games.jass.logic.data.models.rules.Rules;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.rules {
+    abstract class RulesSetType {
+        private constructor();
+        static get belot(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "belot";
+            get ordinal(): 0;
+        };
+        static get klabor(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "klabor";
+            get ordinal(): 1;
+        };
+        static get debertzCommon(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "debertzCommon";
+            get ordinal(): 2;
+        };
+        static get debertzKharkiv(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "debertzKharkiv";
+            get ordinal(): 3;
+        };
+        static get debertzSaltivka(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "debertzSaltivka";
+            get ordinal(): 4;
+        };
+        static get custom(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "custom";
+            get ordinal(): 5;
+        };
+        get name(): "belot" | "klabor" | "debertzCommon" | "debertzKharkiv" | "debertzSaltivka" | "custom";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        get value(): string;
+        getRules(): games.jass.logic.data.models.rules.Rules;
+        get isCustom(): boolean;
+        static values(): Array<games.jass.logic.data.models.rules.RulesSetType>;
+        static valueOf(value: string): games.jass.logic.data.models.rules.RulesSetType;
+    }
+}
+export declare namespace games.jass.logic.data.models.scenes {
     interface ActData {
         readonly actId: string;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.data.models.scenes.ActData": unique symbol;
+            readonly "games.jass.logic.data.models.scenes.ActData": unique symbol;
         };
     }
 }
-export declare namespace com.debertz.logic.data.models.scenes {
+export declare namespace games.jass.logic.data.models.scenes {
     interface SceneData {
         readonly sceneId: string;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.data.models.scenes.SceneData": unique symbol;
+            readonly "games.jass.logic.data.models.scenes.SceneData": unique symbol;
         };
     }
 }
-export declare namespace com.debertz.logic.data.models.table {
-    class DebertzTable {
-        constructor(id: string, version: string, createdAt: any/* kotlinx.datetime.Instant */, config: com.debertz.logic.data.models.table.config.Config, players: any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */, sceneInfo: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable: any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTable> */, bribes: any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */, cardDeck: Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */, gameInfo: any/* com.debertz.logic.data.models.table.GameInfo */);
+export declare namespace games.jass.logic.data.models.table {
+    class JassTable {
+        constructor(id: string, version: string, createdAt: any/* kotlinx.datetime.Instant */, config: games.jass.logic.data.models.table.config.Config, players: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.JassPlayer */>, sceneInfo: any/* games.jass.logic.data.models.table.scene.SceneInfo */, cardsOnTable: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.table.bribes.CardOnTable */>, bribes: kotlin.collections.KtList<any/* games.jass.logic.data.models.table.cards.Bribe */>, cardDeck: Nullable<any>/* Nullable<games.jass.logic.data.models.table.cards.CardDeck> */, gameInfo: any/* games.jass.logic.data.models.table.GameInfo */, gameHistory: games.jass.logic.data.models.table.history.GameHistory);
         get id(): string;
         get version(): string;
         get createdAt(): any/* kotlinx.datetime.Instant */;
-        get config(): com.debertz.logic.data.models.table.config.Config;
-        get players(): any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */;
-        get sceneInfo(): any/* com.debertz.logic.data.models.table.scene.SceneInfo */;
-        get cardsOnTable(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTable> */;
-        get bribes(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */;
-        get cardDeck(): Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */;
-        get gameInfo(): any/* com.debertz.logic.data.models.table.GameInfo */;
+        get config(): games.jass.logic.data.models.table.config.Config;
+        get players(): kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.JassPlayer */>;
+        get sceneInfo(): any/* games.jass.logic.data.models.table.scene.SceneInfo */;
+        get cardsOnTable(): kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.table.bribes.CardOnTable */>;
+        get bribes(): kotlin.collections.KtList<any/* games.jass.logic.data.models.table.cards.Bribe */>;
+        get cardDeck(): Nullable<any>/* Nullable<games.jass.logic.data.models.table.cards.CardDeck> */;
+        get gameInfo(): any/* games.jass.logic.data.models.table.GameInfo */;
+        get gameHistory(): games.jass.logic.data.models.table.history.GameHistory;
+        get gameId(): string;
         get gameDuration(): any/* kotlin.time.Duration */;
-        get playersConnections(): any/* kotlin.collections.List<kotlin.Pair<string, com.logic.data.models.player.PlayerConnectionState>> */;
+        get gameCreatedAt(): any/* kotlinx.datetime.Instant */;
+        get playersConnections(): kotlin.collections.KtList<any/* kotlin.Pair<string, com.logic.data.models.player.PlayerConnectionState> */>;
         get users(): Array<com.logic.data.models.player.GameUserInfo>;
         get isCardDeckExist(): boolean;
-        get requireCardDeck(): any/* com.debertz.logic.data.models.table.cards.CardDeck */;
-        get currentTrump(): Nullable<any>/* Nullable<com.logic.data.models.table.cards.Suit> */;
-        copy(id?: string, version?: string, createdAt?: any/* kotlinx.datetime.Instant */, config?: com.debertz.logic.data.models.table.config.Config, players?: any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */, sceneInfo?: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable?: any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTable> */, bribes?: any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */, cardDeck?: Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */, gameInfo?: any/* com.debertz.logic.data.models.table.GameInfo */): com.debertz.logic.data.models.table.DebertzTable;
+        get requireCardDeck(): any/* games.jass.logic.data.models.table.cards.CardDeck */;
+        get currentTrump(): Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */;
+        get isGameFinished(): boolean;
         toString(): string;
+        copy(id?: string, version?: string, createdAt?: any/* kotlinx.datetime.Instant */, config?: games.jass.logic.data.models.table.config.Config, players?: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.JassPlayer */>, sceneInfo?: any/* games.jass.logic.data.models.table.scene.SceneInfo */, cardsOnTable?: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.table.bribes.CardOnTable */>, bribes?: kotlin.collections.KtList<any/* games.jass.logic.data.models.table.cards.Bribe */>, cardDeck?: Nullable<any>/* Nullable<games.jass.logic.data.models.table.cards.CardDeck> */, gameInfo?: any/* games.jass.logic.data.models.table.GameInfo */, gameHistory?: games.jass.logic.data.models.table.history.GameHistory): games.jass.logic.data.models.table.JassTable;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         static get Companion(): {
-            initial(id: string, version: string, config: com.debertz.logic.data.models.table.config.Config, players: any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */): com.debertz.logic.data.models.table.DebertzTable;
+            initial(tableId: string, gameId: string, version: string, config: games.jass.logic.data.models.table.config.Config, players: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.JassPlayer */>): games.jass.logic.data.models.table.JassTable;
         };
     }
 }
-export declare namespace com.debertz.logic.data.models.table {
-    class TableLoggerPayload implements com.logic.utils.logger.game.LoggerPayload {
-        constructor(id: string, players: Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>);
+export declare namespace games.jass.logic.data.models.table {
+    class TableLoggerPayload implements games.raspberry.logger.LoggerPayload {
+        constructor(id: string, gameId: string, players: Array<games.jass.logic.data.models.table.PlayerLoggerPayload>);
         get id(): string;
-        get players(): Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>;
-        toString(): string;
+        get gameId(): string;
+        get players(): Array<games.jass.logic.data.models.table.PlayerLoggerPayload>;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        copy(id?: string, players?: Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>): com.debertz.logic.data.models.table.TableLoggerPayload;
-        readonly __doNotUseOrImplementIt: com.logic.utils.logger.game.LoggerPayload["__doNotUseOrImplementIt"];
+        toString(): string;
+        copy(id?: string, gameId?: string, players?: Array<games.jass.logic.data.models.table.PlayerLoggerPayload>): games.jass.logic.data.models.table.TableLoggerPayload;
+        readonly __doNotUseOrImplementIt: games.raspberry.logger.LoggerPayload["__doNotUseOrImplementIt"];
     }
-    class PlayerLoggerPayload implements com.logic.utils.logger.game.LoggerPayload {
+    class PlayerLoggerPayload implements games.raspberry.logger.LoggerPayload {
         constructor(playerId: string, connectionState: Nullable<com.logic.data.models.player.PlayerConnectionState>);
         get playerId(): string;
         get connectionState(): Nullable<com.logic.data.models.player.PlayerConnectionState>;
         toString(): string;
-        copy(playerId?: string, connectionState?: Nullable<com.logic.data.models.player.PlayerConnectionState>): com.debertz.logic.data.models.table.PlayerLoggerPayload;
+        copy(playerId?: string, connectionState?: Nullable<com.logic.data.models.player.PlayerConnectionState>): games.jass.logic.data.models.table.PlayerLoggerPayload;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: games.raspberry.logger.LoggerPayload["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.table.combinations {
+    class Combination /* implements games.jass.logic.data.models.table.combinations.CombinationContract */ {
+        constructor(id: string, type: games.jass.logic.data.models.table.combinations.CombinationType, cards: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>, reasons: kotlin.collections.KtSet<games.jass.logic.data.models.messages.combinatios.CombinationReason>);
+        toString(): string;
+        copy(id?: string, type?: games.jass.logic.data.models.table.combinations.CombinationType, cards?: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>, reasons?: kotlin.collections.KtSet<games.jass.logic.data.models.messages.combinatios.CombinationReason>): games.jass.logic.data.models.table.combinations.Combination;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        readonly __doNotUseOrImplementIt: com.logic.utils.logger.game.LoggerPayload["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace com.debertz.logic.data.models.table.config {
+export declare namespace games.jass.logic.data.models.table.combinations {
+    abstract class CombinationState {
+        private constructor();
+        static get NOT_VERIFIED(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "NOT_VERIFIED";
+            get ordinal(): 0;
+        };
+        static get VERIFYING(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "VERIFYING";
+            get ordinal(): 1;
+        };
+        static get ACCEPTED(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "ACCEPTED";
+            get ordinal(): 2;
+        };
+        static get NOT_ACCEPTED(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "NOT_ACCEPTED";
+            get ordinal(): 3;
+        };
+        static get REJECTED(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "REJECTED";
+            get ordinal(): 4;
+        };
+        static get CANCELED(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "CANCELED";
+            get ordinal(): 5;
+        };
+        get name(): "NOT_VERIFIED" | "VERIFYING" | "ACCEPTED" | "NOT_ACCEPTED" | "REJECTED" | "CANCELED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        static values(): Array<games.jass.logic.data.models.table.combinations.CombinationState>;
+        static valueOf(value: string): games.jass.logic.data.models.table.combinations.CombinationState;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.combinations {
+    abstract class CombinationType {
+        private constructor();
+        static get BELA(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BELA";
+            get ordinal(): 0;
+        };
+        static get THREE_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "THREE_IN_ROW";
+            get ordinal(): 1;
+        };
+        static get FOUR_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_IN_ROW";
+            get ordinal(): 2;
+        };
+        static get FIVE_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FIVE_IN_ROW";
+            get ordinal(): 3;
+        };
+        static get SEVEN_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "SEVEN_IN_ROW";
+            get ordinal(): 4;
+        };
+        static get SEVEN_TRUMP(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "SEVEN_TRUMP";
+            get ordinal(): 5;
+        };
+        static get FOUR_ACES(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_ACES";
+            get ordinal(): 6;
+        };
+        static get FOUR_KINGS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_KINGS";
+            get ordinal(): 7;
+        };
+        static get FOUR_DAMES(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_DAMES";
+            get ordinal(): 8;
+        };
+        static get FOUR_JACKS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_JACKS";
+            get ordinal(): 9;
+        };
+        static get FOUR_TENS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_TENS";
+            get ordinal(): 10;
+        };
+        static get FOUR_NINES(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_NINES";
+            get ordinal(): 11;
+        };
+        static get FOUR_SEVENS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_SEVENS";
+            get ordinal(): 12;
+        };
+        static get FINE_NO_BRIBES(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FINE_NO_BRIBES";
+            get ordinal(): 13;
+        };
+        static get FINE_THIRD_FAILED_CONTRACT(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FINE_THIRD_FAILED_CONTRACT";
+            get ordinal(): 14;
+        };
+        static get BONUS_LAST_BRIBE(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BONUS_LAST_BRIBE";
+            get ordinal(): 15;
+        };
+        static get BONUS_FAILED_CONTRACT(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BONUS_FAILED_CONTRACT";
+            get ordinal(): 16;
+        };
+        static get BONUS_CONTROVERSIAL_CONTRACT(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BONUS_CONTROVERSIAL_CONTRACT";
+            get ordinal(): 17;
+        };
+        get name(): "BELA" | "THREE_IN_ROW" | "FOUR_IN_ROW" | "FIVE_IN_ROW" | "SEVEN_IN_ROW" | "SEVEN_TRUMP" | "FOUR_ACES" | "FOUR_KINGS" | "FOUR_DAMES" | "FOUR_JACKS" | "FOUR_TENS" | "FOUR_NINES" | "FOUR_SEVENS" | "FINE_NO_BRIBES" | "FINE_THIRD_FAILED_CONTRACT" | "BONUS_LAST_BRIBE" | "BONUS_FAILED_CONTRACT" | "BONUS_CONTROVERSIAL_CONTRACT";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17;
+        static values(): Array<games.jass.logic.data.models.table.combinations.CombinationType>;
+        static valueOf(value: string): games.jass.logic.data.models.table.combinations.CombinationType;
+        static get Companion(): {
+            get withFirstCardCombination(): kotlin.collections.KtList<games.jass.logic.data.models.table.combinations.CombinationType>;
+            get inRowCombinations(): kotlin.collections.KtList<games.jass.logic.data.models.table.combinations.CombinationType>;
+            get fourCardsCombinations(): kotlin.collections.KtList<games.jass.logic.data.models.table.combinations.CombinationType>;
+            get debertzWithFirstCardCombinations(): kotlin.collections.KtList<games.jass.logic.data.models.table.combinations.CombinationType>;
+            get belotWithFirstCardCombination(): kotlin.collections.KtList<games.jass.logic.data.models.table.combinations.CombinationType>;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.combinations {
+    class PlayerCombinations implements com.logic.data.models.player.PlayerIdContract {
+        constructor(playerId: string, combinations: Array<games.jass.logic.data.models.table.combinations.Combination>);
+        get playerId(): string;
+        get combinations(): Array<games.jass.logic.data.models.table.combinations.Combination>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(playerId?: string, combinations?: Array<games.jass.logic.data.models.table.combinations.Combination>): games.jass.logic.data.models.table.combinations.PlayerCombinations;
+        toString(): string;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.table.config {
     abstract class BotIntelligenceLevel {
         private constructor();
-        static get SUPER_HARD(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
+        static get SUPER_HARD(): games.jass.logic.data.models.table.config.BotIntelligenceLevel & {
             get name(): "SUPER_HARD";
             get ordinal(): 0;
         };
-        static get HARD(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
+        static get HARD(): games.jass.logic.data.models.table.config.BotIntelligenceLevel & {
             get name(): "HARD";
             get ordinal(): 1;
         };
-        static get MEDIUM(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
+        static get MEDIUM(): games.jass.logic.data.models.table.config.BotIntelligenceLevel & {
             get name(): "MEDIUM";
             get ordinal(): 2;
         };
-        static get EASY(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
+        static get EASY(): games.jass.logic.data.models.table.config.BotIntelligenceLevel & {
             get name(): "EASY";
             get ordinal(): 3;
         };
-        static get SUPER_EASY(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
+        static get SUPER_EASY(): games.jass.logic.data.models.table.config.BotIntelligenceLevel & {
             get name(): "SUPER_EASY";
             get ordinal(): 4;
         };
-        static values(): Array<com.debertz.logic.data.models.table.config.BotIntelligenceLevel>;
-        static valueOf(value: string): com.debertz.logic.data.models.table.config.BotIntelligenceLevel;
         get name(): "SUPER_HARD" | "HARD" | "MEDIUM" | "EASY" | "SUPER_EASY";
         get ordinal(): 0 | 1 | 2 | 3 | 4;
+        static values(): Array<games.jass.logic.data.models.table.config.BotIntelligenceLevel>;
+        static valueOf(value: string): games.jass.logic.data.models.table.config.BotIntelligenceLevel;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
-    function getLevel(_this_: com.debertz.logic.data.models.table.config.BotIntelligenceLevel): number;
+    function getLevel(_this_: games.jass.logic.data.models.table.config.BotIntelligenceLevel): number;
 }
-export declare namespace com.debertz.logic.data.models.table.config {
+export declare namespace games.jass.logic.data.models.table.config {
     class Config {
-        constructor(rules: com.logic.data.models.rules.Rules, rulesSetType: com.logic.data.models.rules.RulesSetType, options: com.debertz.logic.data.models.table.config.Options, playersMode: com.debertz.logic.data.models.table.config.PlayersMode, pointsMode: com.debertz.logic.data.models.table.config.PointsMode, timeoutTimeMillis: number, isPrivate: boolean);
-        get rules(): com.logic.data.models.rules.Rules;
-        get rulesSetType(): com.logic.data.models.rules.RulesSetType;
-        get options(): com.debertz.logic.data.models.table.config.Options;
-        get playersMode(): com.debertz.logic.data.models.table.config.PlayersMode;
-        get pointsMode(): com.debertz.logic.data.models.table.config.PointsMode;
+        constructor(rules: games.jass.logic.data.models.rules.Rules, rulesSetType: games.jass.logic.data.models.rules.RulesSetType, options: games.jass.logic.data.models.table.config.Options, playersMode: games.jass.logic.data.models.table.config.PlayersMode, pointsMode: games.jass.logic.data.models.table.config.PointsMode, timeoutTimeMillis: number, isPrivate: boolean);
+        get rules(): games.jass.logic.data.models.rules.Rules;
+        get rulesSetType(): games.jass.logic.data.models.rules.RulesSetType;
+        get options(): games.jass.logic.data.models.table.config.Options;
+        get playersMode(): games.jass.logic.data.models.table.config.PlayersMode;
+        get pointsMode(): games.jass.logic.data.models.table.config.PointsMode;
+        get timeoutTimeMillis(): number;
+        get isPrivate(): boolean;
+        get playerHandCardsSize(): number;
+        copy(rules?: games.jass.logic.data.models.rules.Rules, rulesSetType?: games.jass.logic.data.models.rules.RulesSetType, options?: games.jass.logic.data.models.table.config.Options, playersMode?: games.jass.logic.data.models.table.config.PlayersMode, pointsMode?: games.jass.logic.data.models.table.config.PointsMode, timeoutTimeMillis?: number, isPrivate?: boolean): games.jass.logic.data.models.table.config.Config;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.config {
+    class ConfigLite {
+        constructor(players: games.jass.logic.data.models.table.config.PlayersMode, points: games.jass.logic.data.models.table.config.PointsMode, timeoutTimeMillis: number, rulesPreset: games.jass.logic.data.models.rules.RulesSetType, isPrivate: boolean, isChatEnabled: boolean, isBotsEnabled: boolean, rules: Nullable<games.jass.logic.data.models.rules.Rules>);
+        get players(): games.jass.logic.data.models.table.config.PlayersMode;
+        get points(): games.jass.logic.data.models.table.config.PointsMode;
         get timeoutTimeMillis(): number;
+        get rulesPreset(): games.jass.logic.data.models.rules.RulesSetType;
         get isPrivate(): boolean;
-        copy(rules?: com.logic.data.models.rules.Rules, rulesSetType?: com.logic.data.models.rules.RulesSetType, options?: com.debertz.logic.data.models.table.config.Options, playersMode?: com.debertz.logic.data.models.table.config.PlayersMode, pointsMode?: com.debertz.logic.data.models.table.config.PointsMode, timeoutTimeMillis?: number, isPrivate?: boolean): com.debertz.logic.data.models.table.config.Config;
+        get isChatEnabled(): boolean;
+        get isBotsEnabled(): boolean;
+        get rules(): Nullable<games.jass.logic.data.models.rules.Rules>;
+        copy(players?: games.jass.logic.data.models.table.config.PlayersMode, points?: games.jass.logic.data.models.table.config.PointsMode, timeoutTimeMillis?: number, rulesPreset?: games.jass.logic.data.models.rules.RulesSetType, isPrivate?: boolean, isChatEnabled?: boolean, isBotsEnabled?: boolean, rules?: Nullable<games.jass.logic.data.models.rules.Rules>): games.jass.logic.data.models.table.config.ConfigLite;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
 }
-export declare namespace com.debertz.logic.data.models.table.config {
+export declare namespace games.jass.logic.data.models.table.config {
     class Options {
-        constructor(isEnableChat?: boolean, botIntelligenceLevel?: com.debertz.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: boolean, isEnablePreviewScreen?: boolean);
+        constructor(isEnableChat?: boolean, isBotsEnabled?: boolean, botIntelligenceLevel?: games.jass.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: boolean);
         get isEnableChat(): boolean;
-        get botIntelligenceLevel(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel;
+        get isBotsEnabled(): boolean;
+        get botIntelligenceLevel(): games.jass.logic.data.models.table.config.BotIntelligenceLevel;
         get timeForCountdownMillis(): number;
         get timeForBotMillis(): number;
         get isEnableChoosePartnerScreen(): boolean;
-        get isEnablePreviewScreen(): boolean;
-        copy(isEnableChat?: boolean, botIntelligenceLevel?: com.debertz.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: boolean, isEnablePreviewScreen?: boolean): com.debertz.logic.data.models.table.config.Options;
+        copy(isEnableChat?: boolean, isBotsEnabled?: boolean, botIntelligenceLevel?: games.jass.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: boolean): games.jass.logic.data.models.table.config.Options;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
 }
-export declare namespace com.debertz.logic.data.models.table.config {
+export declare namespace games.jass.logic.data.models.table.config {
     abstract class PlayersMode {
         private constructor();
-        get value(): number;
-        static get TWO_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
+        static get TWO_PLAYERS(): games.jass.logic.data.models.table.config.PlayersMode & {
             get name(): "TWO_PLAYERS";
             get ordinal(): 0;
         };
-        static get THREE_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
+        static get THREE_PLAYERS(): games.jass.logic.data.models.table.config.PlayersMode & {
             get name(): "THREE_PLAYERS";
             get ordinal(): 1;
         };
-        static get FOUR_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
+        static get FOUR_PLAYERS(): games.jass.logic.data.models.table.config.PlayersMode & {
             get name(): "FOUR_PLAYERS";
             get ordinal(): 2;
         };
-        static get FOUR_PLAYERS_BY_TEAM(): com.debertz.logic.data.models.table.config.PlayersMode & {
+        static get FOUR_PLAYERS_BY_TEAM(): games.jass.logic.data.models.table.config.PlayersMode & {
             get name(): "FOUR_PLAYERS_BY_TEAM";
             get ordinal(): 3;
         };
-        get isTeamGame(): boolean;
-        get count(): number;
-        static values(): Array<com.debertz.logic.data.models.table.config.PlayersMode>;
-        static valueOf(value: string): com.debertz.logic.data.models.table.config.PlayersMode;
         get name(): "TWO_PLAYERS" | "THREE_PLAYERS" | "FOUR_PLAYERS" | "FOUR_PLAYERS_BY_TEAM";
         get ordinal(): 0 | 1 | 2 | 3;
+        get value(): number;
+        get isTeamGame(): boolean;
+        get count(): number;
+        static values(): Array<games.jass.logic.data.models.table.config.PlayersMode>;
+        static valueOf(value: string): games.jass.logic.data.models.table.config.PlayersMode;
         static get Companion(): {
-            create(points: number): com.debertz.logic.data.models.table.config.PlayersMode;
+            create(points: number): games.jass.logic.data.models.table.config.PlayersMode;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
-export declare namespace com.debertz.logic.data.models.table.config {
+export declare namespace games.jass.logic.data.models.table.config {
     abstract class PointsMode {
         private constructor();
-        get value(): number;
-        static get SMALL(): com.debertz.logic.data.models.table.config.PointsMode & {
+        static get SMALL(): games.jass.logic.data.models.table.config.PointsMode & {
             get name(): "SMALL";
             get ordinal(): 0;
         };
-        static get MEDIUM(): com.debertz.logic.data.models.table.config.PointsMode & {
+        static get MEDIUM(): games.jass.logic.data.models.table.config.PointsMode & {
             get name(): "MEDIUM";
             get ordinal(): 1;
         };
-        static get BIG(): com.debertz.logic.data.models.table.config.PointsMode & {
+        static get BIG(): games.jass.logic.data.models.table.config.PointsMode & {
             get name(): "BIG";
             get ordinal(): 2;
         };
-        static get TEST(): com.debertz.logic.data.models.table.config.PointsMode & {
+        static get TEST(): games.jass.logic.data.models.table.config.PointsMode & {
             get name(): "TEST";
             get ordinal(): 3;
         };
-        static values(): Array<com.debertz.logic.data.models.table.config.PointsMode>;
-        static valueOf(value: string): com.debertz.logic.data.models.table.config.PointsMode;
         get name(): "SMALL" | "MEDIUM" | "BIG" | "TEST";
         get ordinal(): 0 | 1 | 2 | 3;
+        get value(): number;
+        static values(): Array<games.jass.logic.data.models.table.config.PointsMode>;
+        static valueOf(value: string): games.jass.logic.data.models.table.config.PointsMode;
         static get Companion(): {
-            create(points: number): com.debertz.logic.data.models.table.config.PointsMode;
+            create(points: number): games.jass.logic.data.models.table.config.PointsMode;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
-export declare namespace com.debertz.logic.domain.interactors.dealer {
+export declare namespace games.jass.logic.data.models.table.history {
+    class GameHistory {
+        constructor(gameId: string, createdAt: any/* kotlinx.datetime.Instant */, rounds: Array<games.jass.logic.data.models.table.history.RoundHistory>, gameWinners: Nullable<Array<string>>, metadata: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>);
+        get gameId(): string;
+        get createdAt(): any/* kotlinx.datetime.Instant */;
+        get rounds(): Array<games.jass.logic.data.models.table.history.RoundHistory>;
+        get gameWinners(): Nullable<Array<string>>;
+        get metadata(): Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>;
+        get date(): string;
+        get lastRoundHistory(): games.jass.logic.data.models.table.history.RoundHistory;
+        get isFirstRound(): boolean;
+        get roundsCount(): number;
+        toString(): string;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(gameId?: string, createdAt?: any/* kotlinx.datetime.Instant */, rounds?: Array<games.jass.logic.data.models.table.history.RoundHistory>, gameWinners?: Nullable<Array<string>>, metadata?: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>): games.jass.logic.data.models.table.history.GameHistory;
+        static get Companion(): {
+            initial(gameId: string, createdAt?: any/* kotlinx.datetime.Instant */): games.jass.logic.data.models.table.history.GameHistory;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.table.history {
+    class GameHistoryMetadata {
+        constructor(randomData: Nullable<games.jass.logic.data.models.dealer.RandomData>, playersAnalytics: kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics>);
+        get randomData(): Nullable<games.jass.logic.data.models.dealer.RandomData>;
+        get playersAnalytics(): kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics>;
+        copy(randomData?: Nullable<games.jass.logic.data.models.dealer.RandomData>, playersAnalytics?: kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics>): games.jass.logic.data.models.table.history.GameHistoryMetadata;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            initial(): games.jass.logic.data.models.table.history.GameHistoryMetadata;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.table.history {
+    class RoundHistory {
+        constructor(roundNumber: number, items: Array<games.jass.logic.data.models.table.history.RoundHistoryItem>, roundCommitted: Nullable<Array<string>>, roundContractState: Nullable<games.jass.logic.data.models.player.state.RoundContractState>, roundWinners: Nullable<Array<string>>);
+        get roundNumber(): number;
+        get items(): Array<games.jass.logic.data.models.table.history.RoundHistoryItem>;
+        get roundCommitted(): Nullable<Array<string>>;
+        get roundContractState(): Nullable<games.jass.logic.data.models.player.state.RoundContractState>;
+        get roundWinners(): Nullable<Array<string>>;
+        get roundContractStateName(): Nullable<string>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        toStringShort(): string;
+        copy(roundNumber?: number, items?: Array<games.jass.logic.data.models.table.history.RoundHistoryItem>, roundCommitted?: Nullable<Array<string>>, roundContractState?: Nullable<games.jass.logic.data.models.player.state.RoundContractState>, roundWinners?: Nullable<Array<string>>): games.jass.logic.data.models.table.history.RoundHistory;
+        toString(): string;
+        static get Companion(): {
+            initial(roundNumber: number): games.jass.logic.data.models.table.history.RoundHistory;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.table.history {
+    abstract class RoundHistoryItem {
+        protected constructor();
+        abstract get createdAt(): any/* kotlinx.datetime.Instant */;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.round {
+    class Round {
+        constructor(roundNumber: number, numberOfBribe: Nullable<number>, trump: Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */);
+        get roundNumber(): number;
+        get numberOfBribe(): Nullable<number>;
+        get trump(): Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */;
+        get selectedTrump(): any/* io.raspberryapps.card_game.core.data.models.cards.Suit */;
+        get numberOfBribeOrZero(): number;
+        copy(roundNumber?: number, numberOfBribe?: Nullable<number>, trump?: Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */): games.jass.logic.data.models.table.round.Round;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            initial(): games.jass.logic.data.models.table.round.Round;
+        };
+    }
+}
+export declare namespace games.jass.logic.domain.interactors.dealer {
     abstract class DealerStrategy {
         private constructor();
-        static get FAKE(): com.debertz.logic.domain.interactors.dealer.DealerStrategy & {
+        static get FAKE(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
             get name(): "FAKE";
             get ordinal(): 0;
         };
-        static get BASED_ON_PREVIOUS(): com.debertz.logic.domain.interactors.dealer.DealerStrategy & {
+        static get BASED_ON_PREVIOUS(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
             get name(): "BASED_ON_PREVIOUS";
             get ordinal(): 1;
         };
-        static get EQUAL_HAND_BY_POINTS(): com.debertz.logic.domain.interactors.dealer.DealerStrategy & {
+        static get EQUAL_HAND_BY_POINTS(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
             get name(): "EQUAL_HAND_BY_POINTS";
             get ordinal(): 2;
         };
-        static get EQUAL_HAND_BY_VALUE(): com.debertz.logic.domain.interactors.dealer.DealerStrategy & {
+        static get EQUAL_HAND_BY_VALUE(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
             get name(): "EQUAL_HAND_BY_VALUE";
             get ordinal(): 3;
         };
-        static get RANDOM(): com.debertz.logic.domain.interactors.dealer.DealerStrategy & {
+        static get RANDOM(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
             get name(): "RANDOM";
             get ordinal(): 4;
         };
+        static get RANDOM_ORG(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "RANDOM_ORG";
+            get ordinal(): 5;
+        };
+        static get RANDOM_ORG_SIGNED(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "RANDOM_ORG_SIGNED";
+            get ordinal(): 6;
+        };
+        get name(): "FAKE" | "BASED_ON_PREVIOUS" | "EQUAL_HAND_BY_POINTS" | "EQUAL_HAND_BY_VALUE" | "RANDOM" | "RANDOM_ORG" | "RANDOM_ORG_SIGNED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
         shouldEqualiseHand(): boolean;
-        static values(): Array<com.debertz.logic.domain.interactors.dealer.DealerStrategy>;
-        static valueOf(value: string): com.debertz.logic.domain.interactors.dealer.DealerStrategy;
-        get name(): "FAKE" | "BASED_ON_PREVIOUS" | "EQUAL_HAND_BY_POINTS" | "EQUAL_HAND_BY_VALUE" | "RANDOM";
-        get ordinal(): 0 | 1 | 2 | 3 | 4;
+        static values(): Array<games.jass.logic.domain.interactors.dealer.DealerStrategy>;
+        static valueOf(value: string): games.jass.logic.domain.interactors.dealer.DealerStrategy;
     }
 }
-export declare namespace com.debertz.logic.redux.actions {
+export declare namespace games.jass.logic.redux.actions {
     const ClearAction: {
         toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
         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 {
+export declare namespace games.jass.logic.redux.actions.client.from {
+    abstract class FromClientAction implements com.logic.redux.store.definitions.Action {
         protected constructor();
         abstract get playerId(): string;
+        abstract get fromBot(): 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.client.to {
+export declare namespace games.jass.logic.redux.actions.client.to {
     class ActionDeliveryPayload {
-        constructor(roomId: string, includePlayers: Array<string>, excludePlayers: Array<string>, deliveryType: com.debertz.logic.redux.actions.client.to.ActionDeliveryType);
-        get roomId(): string;
+        constructor(tableId: string, aid: string, includePlayers: Array<string>, excludePlayers: Array<string>, deliveryType: games.jass.logic.redux.actions.client.to.ActionDeliveryType);
+        get id(): string;
+        get aid(): string;
         get includePlayers(): Array<string>;
         get excludePlayers(): Array<string>;
-        get deliveryType(): com.debertz.logic.redux.actions.client.to.ActionDeliveryType;
+        get deliveryType(): games.jass.logic.redux.actions.client.to.ActionDeliveryType;
         get excludePlayerOrNull(): Nullable<string>;
         get sendToPlayerId(): string;
         get excludePlayerId(): string;
+        toString(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        copy(roomId?: 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(tableId?: string, aid?: string, includePlayers?: Array<string>, excludePlayers?: Array<string>, deliveryType?: games.jass.logic.redux.actions.client.to.ActionDeliveryType): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
         static get Companion(): {
-            user(roomId: string, sendToPlayerId: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
+            userFromTable(aid: string, table: games.jass.logic.data.models.table.JassTable, sendToPlayerId: string): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
+            user(aid: string, tableId: string, sendToPlayerId: string): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
         };
     }
     abstract class ActionDeliveryType {
         private constructor();
-        static get ROOM_ALL(): com.debertz.logic.redux.actions.client.to.ActionDeliveryType & {
+        static get ROOM_ALL(): games.jass.logic.redux.actions.client.to.ActionDeliveryType & {
             get name(): "ROOM_ALL";
             get ordinal(): 0;
         };
-        static get ROOM_EXCEPT_USER(): com.debertz.logic.redux.actions.client.to.ActionDeliveryType & {
+        static get ROOM_EXCEPT_USER(): games.jass.logic.redux.actions.client.to.ActionDeliveryType & {
             get name(): "ROOM_EXCEPT_USER";
             get ordinal(): 1;
         };
-        static get USER(): com.debertz.logic.redux.actions.client.to.ActionDeliveryType & {
+        static get USER(): games.jass.logic.redux.actions.client.to.ActionDeliveryType & {
             get name(): "USER";
             get ordinal(): 2;
         };
-        static values(): Array<com.debertz.logic.redux.actions.client.to.ActionDeliveryType>;
-        static valueOf(value: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryType;
         get name(): "ROOM_ALL" | "ROOM_EXCEPT_USER" | "USER";
         get ordinal(): 0 | 1 | 2;
+        static values(): Array<games.jass.logic.redux.actions.client.to.ActionDeliveryType>;
+        static valueOf(value: string): games.jass.logic.redux.actions.client.to.ActionDeliveryType;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
-export declare namespace com.debertz.logic.redux.actions.client.to {
-    abstract class ToClientAction implements com.logic.domain.engine.definitions.Action {
+export declare namespace games.jass.logic.redux.actions.client.to {
+    abstract class ToClientAction implements com.logic.redux.store.definitions.Action {
         protected constructor();
-        abstract get deliveryPayload(): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
+        abstract get deliveryPayload(): games.jass.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 {
+export declare namespace games.jass.logic.redux.actions.game {
+    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 PartyStartedAction extends com.debertz.logic.redux.actions.game.GameAction {
-        constructor(roomId: string, partyNumber: number, players: Array<string>, isFirstParty: boolean, gameNumber: number);
-        get roomId(): string;
+    class RoundStartedAction extends games.jass.logic.redux.actions.game.GameAction {
+        constructor(id: string, gameId: string, roundNumber: number, players: Array<string>, isFirstRound: boolean, gameNumber: number, gameHistory: games.jass.logic.data.models.table.history.GameHistory);
+        get id(): string;
+        get gameId(): string;
         get partyNumber(): number;
         get players(): Array<string>;
-        get isFirstParty(): boolean;
+        get isFirstRound(): boolean;
         get gameNumber(): number;
+        get gameHistory(): games.jass.logic.data.models.table.history.GameHistory;
+        toString(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        toString(): string;
-        copy(roomId?: string, partyNumber?: number, players?: Array<string>, isFirstParty?: boolean, gameNumber?: number): com.debertz.logic.redux.actions.game.PartyStartedAction;
+        copy(id?: string, gameId?: string, roundNumber?: number, players?: Array<string>, isFirstRound?: boolean, gameNumber?: number, gameHistory?: games.jass.logic.data.models.table.history.GameHistory): games.jass.logic.redux.actions.game.RoundStartedAction;
         get actionTag(): string;
     }
-    class PartyEndedAction extends com.debertz.logic.redux.actions.game.GameAction {
-        constructor(roomId: string, partyNumber: number, earnedBiggestPointPlayerId: string, partyLosers: Array<string>, partyWinners: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>, luckyFactors?: Nullable<Array<com.logic.data.models.player.PlayerLuckyFactor>>);
-        get roomId(): string;
-        get partyNumber(): number;
+    class RoundEndedAction extends games.jass.logic.redux.actions.game.GameAction {
+        constructor(id: string, gameId: string, roundNumber: number, earnedBiggestPointPlayerId: string, gameLosers: Nullable<Array<string>> | undefined, gameWinners: Nullable<Array<string>> | undefined, playersGameAnalytics: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, playersRoundAnalytics: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, achievements: Nullable<Array<games.jass.logic.data.models.player.achievements.PlayerAchievements>>, gameHistory: games.jass.logic.data.models.table.history.GameHistory);
+        get id(): string;
+        get gameId(): string;
+        get roundNumber(): number;
         get earnedBiggestPointPlayerId(): string;
-        get partyLosers(): Array<string>;
-        get partyWinners(): Array<string>;
         get gameLosers(): Nullable<Array<string>>;
         get gameWinners(): Nullable<Array<string>>;
-        get luckyFactors(): Nullable<Array<com.logic.data.models.player.PlayerLuckyFactor>>;
+        get playersGameAnalytics(): Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>;
+        get playersRoundAnalytics(): Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>;
+        get achievements(): Nullable<Array<games.jass.logic.data.models.player.achievements.PlayerAchievements>>;
+        get gameHistory(): games.jass.logic.data.models.table.history.GameHistory;
         get isGameFinished(): boolean;
+        toString(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        toString(): string;
-        copy(roomId?: string, partyNumber?: number, earnedBiggestPointPlayerId?: string, partyLosers?: Array<string>, partyWinners?: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>, luckyFactors?: Nullable<Array<com.logic.data.models.player.PlayerLuckyFactor>>): com.debertz.logic.redux.actions.game.PartyEndedAction;
+        copy(id?: string, gameId?: string, roundNumber?: number, earnedBiggestPointPlayerId?: string, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>, playersGameAnalytics?: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, playersRoundAnalytics?: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, achievements?: Nullable<Array<games.jass.logic.data.models.player.achievements.PlayerAchievements>>, gameHistory?: games.jass.logic.data.models.table.history.GameHistory): games.jass.logic.redux.actions.game.RoundEndedAction;
         get actionTag(): string;
     }
-    class PartyRestartedAction implements com.logic.domain.engine.definitions.Action {
-        constructor(roomId: string, partyNumber: number);
-        get roomId(): string;
+    class PartyRestartedAction implements com.logic.redux.store.definitions.Action {
+        constructor(id: string, roundNumber: number);
+        get id(): string;
         get partyNumber(): number;
-        copy(roomId?: string, partyNumber?: number): com.debertz.logic.redux.actions.game.PartyRestartedAction;
+        copy(id?: string, roundNumber?: number): games.jass.logic.redux.actions.game.PartyRestartedAction;
         toString(): string;
         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 games.jass.logic.redux.actions.mechanic {
+    class GameToRoomTransition {
+        constructor(roomId: string, playerIds: kotlin.collections.KtList<string>);
+        get roomId(): string;
+        get playerIds(): kotlin.collections.KtList<string>;
+        copy(roomId?: string, playerIds?: kotlin.collections.KtList<string>): games.jass.logic.redux.actions.mechanic.GameToRoomTransition;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
     }
 }
-export declare namespace com.debertz.logic.redux.actions.mechanic {
+export declare namespace games.jass.logic.redux.actions.mechanic {
     abstract class MechanicAction implements com.logic.redux.actions.BufferedAction {
         protected constructor();
+        abstract get aid(): Nullable<string>;
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: com.logic.redux.actions.BufferedAction["__doNotUseOrImplementIt"];
     }
-    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);
+    interface FirstMechanicAction extends com.logic.redux.store.definitions.Action, com.logic.redux.actions.IgnoreBufferForAction {
+        readonly id: string;
+        readonly version: string;
+        readonly users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>;
+        readonly config: games.jass.logic.data.models.table.config.Config;
+        readonly gameCreatorPlayerId: string;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.jass.logic.redux.actions.mechanic.FirstMechanicAction": unique symbol;
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.IgnoreBufferForAction["__doNotUseOrImplementIt"];
+    }
+    class StartGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements games.jass.logic.redux.actions.mechanic.FirstMechanicAction {
+        constructor(config: games.jass.logic.data.models.table.config.Config, roomId: string, version: string, gameCreatorPlayerId: string, users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>, aid?: Nullable<string>);
+        get config(): games.jass.logic.data.models.table.config.Config;
+        get id(): string;
+        get version(): string;
+        get gameCreatorPlayerId(): string;
+        get users(): kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>;
+        get aid(): Nullable<string>;
+        copy(config?: games.jass.logic.data.models.table.config.Config, roomId?: string, version?: string, gameCreatorPlayerId?: string, users?: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.StartGameMechanicAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.FirstMechanicAction["__doNotUseOrImplementIt"];
+    }
+    class StartNewGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction {
+        constructor(previousGameId: string, gameId: string, aid?: Nullable<string>);
+        get previousGameId(): string;
+        get gameId(): string;
+        get aid(): Nullable<string>;
+        copy(previousGameId?: string, gameId?: string, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.StartNewGameMechanicAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+    }
+    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
+    class FinishingGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements games.jass.logic.redux.actions.mechanic.TerminatedAction, com.logic.redux.actions.validation.NotValidateIfGameFinishing {
+        constructor(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, transition?: Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>, sessionAnalytics?: Nullable<games.jass.logic.data.models.GameSessionAnalytics>, gameHistory?: Nullable<games.jass.logic.data.models.table.history.GameHistory>, aid?: Nullable<string>);
         get reason(): com.logic.data.models.TerminationGameReason;
-        copy(reason?: com.logic.data.models.TerminationGameReason): com.debertz.logic.redux.actions.mechanic.FinishingGameMechanicAction;
+        get isGameFinished(): boolean;
+        get transition(): Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>;
+        get sessionAnalytics(): Nullable<games.jass.logic.data.models.GameSessionAnalytics>;
+        get gameHistory(): Nullable<games.jass.logic.data.models.table.history.GameHistory>;
+        get aid(): Nullable<string>;
         toString(): string;
+        copy(reason?: com.logic.data.models.TerminationGameReason, isGameFinished?: boolean, transition?: Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>, sessionAnalytics?: Nullable<games.jass.logic.data.models.GameSessionAnalytics>, gameHistory?: Nullable<games.jass.logic.data.models.table.history.GameHistory>, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.FinishingGameMechanicAction;
         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.TerminatedAction["__doNotUseOrImplementIt"];
+        notValidateWhenFinishing(): boolean;
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.TerminatedAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"];
+        static get Companion(): {
+            withAnalytics(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, table: Nullable<games.jass.logic.data.models.table.JassTable>, transition?: Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>): games.jass.logic.redux.actions.mechanic.FinishingGameMechanicAction;
+        };
     }
-    class FinishGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.debertz.logic.redux.actions.mechanic.TerminatedAction {
-        constructor(reason: com.logic.data.models.TerminationGameReason);
+    class FinishGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements com.logic.redux.actions.validation.NotValidateIfGameFinishing, games.jass.logic.redux.actions.mechanic.TerminatedAction {
+        constructor(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, aid?: Nullable<string>);
         get reason(): com.logic.data.models.TerminationGameReason;
-        copy(reason?: com.logic.data.models.TerminationGameReason): com.debertz.logic.redux.actions.mechanic.FinishGameMechanicAction;
+        get isGameFinished(): boolean;
+        get aid(): Nullable<string>;
+        copy(reason?: com.logic.data.models.TerminationGameReason, isGameFinished?: boolean, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.FinishGameMechanicAction;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
         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"];
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & games.jass.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 actData: Nullable<games.jass.logic.data.models.scenes.ActData>;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction": unique symbol;
-        } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+            readonly "games.jass.logic.redux.actions.mechanic.NavigationMechanicAction": unique symbol;
+        } & 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 */ {
-        constructor(sceneId: string, actId?: Nullable<string>, scenePayload?: Nullable<com.debertz.logic.data.models.scenes.SceneData>, actPayload?: Nullable<com.debertz.logic.data.models.scenes.ActData>);
+    class SceneMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements games.jass.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/*, games.jass.logic.redux.actions.mechanic.NextPlayerTurnAction */ {
+        constructor(sceneId: string, actId?: Nullable<string>, sceneData?: Nullable<games.jass.logic.data.models.scenes.SceneData>, actData?: Nullable<games.jass.logic.data.models.scenes.ActData>, aid?: Nullable<string>);
         get sceneId(): string;
         get actId(): Nullable<string>;
-        get scenePayload(): Nullable<com.debertz.logic.data.models.scenes.SceneData>;
-        get actPayload(): Nullable<com.debertz.logic.data.models.scenes.ActData>;
+        get sceneData(): Nullable<games.jass.logic.data.models.scenes.SceneData>;
+        get actData(): Nullable<games.jass.logic.data.models.scenes.ActData>;
+        get aid(): Nullable<string>;
         notValidateWhenFinished(): boolean;
         notValidateWhenFinishing(): boolean;
-        copy(sceneId?: string, actId?: Nullable<string>, scenePayload?: Nullable<com.debertz.logic.data.models.scenes.SceneData>, actPayload?: Nullable<com.debertz.logic.data.models.scenes.ActData>): com.debertz.logic.redux.actions.mechanic.SceneMechanicAction;
         toString(): string;
+        copy(sceneId?: string, actId?: Nullable<string>, sceneData?: Nullable<games.jass.logic.data.models.scenes.SceneData>, actData?: Nullable<games.jass.logic.data.models.scenes.ActData>, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.SceneMechanicAction;
         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: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.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 isGameFinished: boolean;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.redux.actions.mechanic.TerminatedAction": unique symbol;
-        } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+            readonly "games.jass.logic.redux.actions.mechanic.TerminatedAction": unique symbol;
+        } & 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>);
+    class PlayerConnectionChangedMechanicAction extends games.jass.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, causeState?: Nullable<com.logic.data.models.player.PlayerConnectionState>, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>, aid?: Nullable<string>);
         get playerId(): string;
         get state(): com.logic.data.models.player.PlayerConnectionState;
+        get causeState(): Nullable<com.logic.data.models.player.PlayerConnectionState>;
         get isNoneActivePlayers(): boolean;
         get reconnectUntilTime(): Nullable<string>;
-        get isLive(): boolean;
-        get isTimeOut(): boolean;
-        get isLostConnection(): boolean;
-        get isLeft(): boolean;
+        get aid(): Nullable<string>;
+        get isShouldBeDisconnectedFromSockets(): boolean;
         get isDeleted(): boolean;
-        get shouldNotifyPlayers(): boolean;
-        copy(playerId?: string, state?: com.logic.data.models.player.PlayerConnectionState, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>): com.debertz.logic.redux.actions.mechanic.PlayerConnectionChangedMechanicAction;
         toString(): string;
+        copy(playerId?: string, state?: com.logic.data.models.player.PlayerConnectionState, causeState?: Nullable<com.logic.data.models.player.PlayerConnectionState>, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.PlayerConnectionChangedMechanicAction;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
         notValidateWhenFinishing(): boolean;
         notValidateWhenFinished(): boolean;
-        readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
     }
 }
 export declare const ERROR: string;
 export declare const DEBUG: string;
 export declare const WARN: string;
 export declare interface ParserHelper {
-    encodeFromClientEvent(action: com.debertz.logic.redux.actions.client.from.FromClientAction): string;
-    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;
+    encodeFromClientEvent(action: games.jass.logic.redux.actions.client.from.FromClientAction): string;
+    decodeFromClientEvent(fromPlayerId: string, json: string): games.jass.logic.redux.actions.client.from.FromClientAction;
+    encodeToClientEvent(action: games.jass.logic.redux.actions.client.to.ToClientAction): string;
+    decodeToClientEventToMechanicActions(playerId: string, engine: games.jass.logic.GameStoreContract, json: string): Array<games.jass.logic.redux.actions.mechanic.MechanicAction>;
+    encodeGameRound(round: games.jass.logic.data.models.table.history.RoundHistory): string;
+    encodeGameRoundItems(round: games.jass.logic.data.models.table.history.RoundHistory): string;
+    encodeGameMetadata(metadata: games.jass.logic.data.models.table.history.GameHistoryMetadata): string;
+    encodeRoomConfig(config: models.RoomConfig): string;
     readonly __doNotUseOrImplementIt: {
         readonly ParserHelper: unique symbol;
     };
 }
-export declare namespace com.debertz.logic.client.domain.mechanic {
-    interface GameMechanic extends com.debertz.logic.GameStoreContract/*, com.debertz.logic.client.domain.scenes.PlayersSceneContract */ {
-        onCreate(): void;
-        onDestroy(): void;
-        getConfig(): com.debertz.logic.data.models.table.config.Config;
-        getClientConfig(): any/* com.debertz.logic.client.data.models.config.ClientConfig */;
-        observeConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.data.models.table.config.Config> */;
-        observeUsers(): any/* kotlinx.coroutines.flow.Flow<kotlin.collections.List<com.logic.data.models.player.GameUserInfo>> */;
-        observeClientConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.ClientConfig> */;
-        observePlayersHandsMetadata(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.PlayersHandsMetadataViewModel> */;
-        observeGameLifecycle(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.GameLifecycleViewModel> */;
-        observeRestartGameExpectant(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.expectants.RestartGameExpectant>> */;
-        observeScene(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.SceneViewModel> */;
-        observeSceneId(): any/* kotlinx.coroutines.flow.Flow<string> */;
-        observeError(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.redux.state.ErrorState>> */;
-        observeInfoMessage(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.data.models.messages.Message>> */;
-        observeGameType(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.GameType> */;
-        observeChatOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
-        observeLastBribe(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.LastBribeViewModel>> */;
-        observeGameInfo(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.GameInfoViewModel>> */;
-        observeSettingsOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
-        switchLastBribe(open: boolean): void;
-        switchGameInfo(open: boolean): void;
-        switchSettings(open: boolean): void;
-        switchChat(open: boolean): void;
-        foreground(foreground: boolean): void;
-        updateConfig(updateConfig: any/* com.debertz.logic.client.data.models.config.UpdateConfigModel */): void;
-        observeShowTutorial(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
-        tutorialPassed(skipped: boolean): void;
-        playerExit(): void;
-        error(error: Nullable<com.debertz.logic.client.redux.state.ErrorState>): void;
-        readonly id: string;
-        readonly table: com.debertz.logic.data.models.table.DebertzTable;
-        readonly isTableExists: boolean;
-        readonly gameLifecycleState: com.debertz.logic.data.models.GameLifecycleState;
-        readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.client.domain.mechanic.GameMechanic": unique symbol;
-        } & com.debertz.logic.GameStoreContract["__doNotUseOrImplementIt"];
+export declare namespace models {
+    class RoomConfig {
+        constructor(players: number, points: number, timeoutTime: number, rulesPreset: string, isPrivate?: Nullable<boolean>, isChatEnabled?: Nullable<boolean>, rules?: Nullable<any>/* Nullable<com.logic.data.models.serializable.rules.RulesDto> */);
+        get players(): number;
+        get points(): number;
+        get timeoutTime(): number;
+        get rulesPreset(): string;
+        get isPrivate(): Nullable<boolean>;
+        get isChatEnabled(): Nullable<boolean>;
+        get rules(): Nullable<any>/* Nullable<com.logic.data.models.serializable.rules.RulesDto> */;
+        copy(players?: number, points?: number, timeoutTime?: number, rulesPreset?: string, isPrivate?: Nullable<boolean>, isChatEnabled?: Nullable<boolean>, rules?: Nullable<any>/* Nullable<com.logic.data.models.serializable.rules.RulesDto> */): models.RoomConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
     }
 }
-export declare namespace com.debertz.logic.client.domain.mechanic.online {
-    interface OnlineGameMechanic extends com.debertz.logic.client.domain.mechanic.GameMechanic {
-        readonly currentPlayerId: string;
-        observeFromClientAction(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.redux.actions.client.from.FromClientAction> */;
-        mechanicAction(action: com.debertz.logic.redux.actions.mechanic.MechanicAction): void;
+export declare namespace games.jass.logic.client.data.models.config {
+    abstract class GameType {
+        private constructor();
+        static get SINGLE(): games.jass.logic.client.data.models.config.GameType & {
+            get name(): "SINGLE";
+            get ordinal(): 0;
+        };
+        static get SERVER(): games.jass.logic.client.data.models.config.GameType & {
+            get name(): "SERVER";
+            get ordinal(): 1;
+        };
+        static get P2P_PARTICIPANT(): games.jass.logic.client.data.models.config.GameType & {
+            get name(): "P2P_PARTICIPANT";
+            get ordinal(): 2;
+        };
+        static get P2P_HOST(): games.jass.logic.client.data.models.config.GameType & {
+            get name(): "P2P_HOST";
+            get ordinal(): 3;
+        };
+        static get TUTORIAL(): games.jass.logic.client.data.models.config.GameType & {
+            get name(): "TUTORIAL";
+            get ordinal(): 4;
+        };
+        get name(): "SINGLE" | "SERVER" | "P2P_PARTICIPANT" | "P2P_HOST" | "TUTORIAL";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
+        static values(): Array<games.jass.logic.client.data.models.config.GameType>;
+        static valueOf(value: string): games.jass.logic.client.data.models.config.GameType;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.client.data.models.config {
+    class GameClientConfig {
+        constructor(validateSceneActiveState?: boolean, validateCardOnMove?: boolean, validateExpectantActions?: boolean, isAutoStepCurrentPlayer?: boolean, areOpponentsCardsOpened?: boolean, sessionAnalytics?: boolean);
+        get validateSceneActiveState(): boolean;
+        get validateCardOnMove(): boolean;
+        get validateExpectantActions(): boolean;
+        get isAutoStepCurrentPlayer(): boolean;
+        get areOpponentsCardsOpened(): boolean;
+        get sessionAnalytics(): boolean;
+        copy(validateSceneActiveState?: boolean, validateCardOnMove?: boolean, validateExpectantActions?: boolean, isAutoStepCurrentPlayer?: boolean, areOpponentsCardsOpened?: boolean, sessionAnalytics?: boolean): games.jass.logic.client.data.models.config.GameClientConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            getClientEngineTestMode(): games.jass.logic.client.data.models.config.GameClientConfig;
+        };
+    }
+}
+export declare namespace games.jass.logic.client.data.models.vm {
+    class GameHistoryViewModel /* extends games.jass.logic.client.data.models.vm.HistoryViewModel */ {
+        constructor(gameId: string, createdAt: any/* kotlinx.datetime.Instant */, gameType: games.jass.logic.client.data.models.config.GameType, users: Array<com.logic.data.models.player.GameUserInfo>, config: games.jass.logic.data.models.table.config.ConfigLite, gameWinners: Nullable<Array<string>>, metadata: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>);
+        get gameId(): string;
+        get createdAt(): any/* kotlinx.datetime.Instant */;
+        get gameType(): games.jass.logic.client.data.models.config.GameType;
+        get users(): Array<com.logic.data.models.player.GameUserInfo>;
+        get config(): games.jass.logic.data.models.table.config.ConfigLite;
+        get gameWinners(): Nullable<Array<string>>;
+        get metadata(): Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        toString(): string;
+        copy(gameId?: string, createdAt?: any/* kotlinx.datetime.Instant */, gameType?: games.jass.logic.client.data.models.config.GameType, users?: Array<com.logic.data.models.player.GameUserInfo>, config?: games.jass.logic.data.models.table.config.ConfigLite, gameWinners?: Nullable<Array<string>>, metadata?: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>): games.jass.logic.client.data.models.vm.GameHistoryViewModel;
+    }
+    class RoundEndedHistoryViewModel /* extends games.jass.logic.client.data.models.vm.HistoryViewModel */ {
+        constructor(gameId: string, roundNumber: number, items: Array<games.jass.logic.data.models.table.history.RoundHistoryItem>, roundContractState: Nullable<games.jass.logic.data.models.player.state.RoundContractState>, roundCommitted: Nullable<Array<string>>, roundWinners: Nullable<Array<string>>, gameEndedHistory: Nullable<games.jass.logic.client.data.models.vm.GameHistoryViewModel>);
+        get gameId(): string;
+        get roundNumber(): number;
+        get items(): Array<games.jass.logic.data.models.table.history.RoundHistoryItem>;
+        get roundContractState(): Nullable<games.jass.logic.data.models.player.state.RoundContractState>;
+        get roundCommitted(): Nullable<Array<string>>;
+        get roundWinners(): Nullable<Array<string>>;
+        get gameEndedHistoryViewModel(): Nullable<games.jass.logic.client.data.models.vm.GameHistoryViewModel>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(gameId?: string, roundNumber?: number, items?: Array<games.jass.logic.data.models.table.history.RoundHistoryItem>, roundContractState?: Nullable<games.jass.logic.data.models.player.state.RoundContractState>, roundCommitted?: Nullable<Array<string>>, roundWinners?: Nullable<Array<string>>, gameEndedHistory?: Nullable<games.jass.logic.client.data.models.vm.GameHistoryViewModel>): games.jass.logic.client.data.models.vm.RoundEndedHistoryViewModel;
+        toString(): string;
+    }
+}
+export declare namespace games.jass.logic.client.domain.mechanic {
+    interface GameMechanic extends games.jass.logic.GameStoreContract/*, games.jass.logic.client.domain.scenes.PlayersSceneContract */ {
         onCreate(): void;
         onDestroy(): void;
-        getConfig(): com.debertz.logic.data.models.table.config.Config;
-        getClientConfig(): any/* com.debertz.logic.client.data.models.config.ClientConfig */;
-        observeConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.data.models.table.config.Config> */;
-        observeUsers(): any/* kotlinx.coroutines.flow.Flow<kotlin.collections.List<com.logic.data.models.player.GameUserInfo>> */;
-        observeClientConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.ClientConfig> */;
-        observePlayersHandsMetadata(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.PlayersHandsMetadataViewModel> */;
-        observeGameLifecycle(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.GameLifecycleViewModel> */;
-        observeRestartGameExpectant(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.expectants.RestartGameExpectant>> */;
-        observeScene(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.SceneViewModel> */;
+        getConfig(): games.jass.logic.data.models.table.config.Config;
+        getClientConfig(): any/* games.jass.logic.client.data.models.config.ClientConfig */;
+        observeConfig(): any/* kotlinx.coroutines.flow.Flow<games.jass.logic.data.models.table.config.Config> */;
+        observeUsers(): any/* kotlinx.coroutines.flow.Flow<kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>> */;
+        observeClientConfig(): any/* kotlinx.coroutines.flow.Flow<games.jass.logic.client.data.models.config.ClientConfig> */;
+        observePlayersHandsMetadata(): any/* kotlinx.coroutines.flow.Flow<games.jass.logic.client.data.models.PlayersHandsMetadataViewModel> */;
+        observeGameLifecycle(): any/* kotlinx.coroutines.flow.Flow<games.jass.logic.client.data.models.GameLifecycleViewModel> */;
+        observeRestartGameExpectant(): any/* kotlinx.coroutines.flow.Flow<Nullable<games.jass.logic.client.data.models.expectants.RestartGameExpectant>> */;
+        observeScene(): any/* kotlinx.coroutines.flow.Flow<games.jass.logic.client.data.models.SceneViewModel> */;
         observeSceneId(): any/* kotlinx.coroutines.flow.Flow<string> */;
-        observeError(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.redux.state.ErrorState>> */;
-        observeInfoMessage(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.data.models.messages.Message>> */;
-        observeGameType(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.GameType> */;
+        observeError(): any/* kotlinx.coroutines.flow.Flow<Nullable<games.jass.logic.data.models.table.error.ErrorState>> */;
+        observeInfoMessage(): any/* kotlinx.coroutines.flow.Flow<Nullable<games.jass.logic.data.models.messages.Message>> */;
+        observeGameType(): any/* kotlinx.coroutines.flow.Flow<games.jass.logic.client.data.models.config.GameType> */;
         observeChatOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
-        observeLastBribe(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.LastBribeViewModel>> */;
-        observeGameInfo(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.GameInfoViewModel>> */;
+        observeLastBribe(): any/* kotlinx.coroutines.flow.Flow<Nullable<games.jass.logic.client.data.models.LastBribeViewModel>> */;
+        observeGameInfo(): any/* kotlinx.coroutines.flow.Flow<Nullable<games.jass.logic.client.data.models.GameInfoViewModel>> */;
         observeSettingsOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
         switchLastBribe(open: boolean): void;
         switchGameInfo(open: boolean): void;
         switchSettings(open: boolean): void;
         switchChat(open: boolean): void;
         foreground(foreground: boolean): void;
-        updateConfig(updateConfig: any/* com.debertz.logic.client.data.models.config.UpdateConfigModel */): void;
+        updateConfig(updateConfig: any/* games.jass.logic.client.data.models.config.UpdateConfigModel */): void;
         observeShowTutorial(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
         tutorialPassed(skipped: boolean): void;
         playerExit(): void;
-        error(error: Nullable<com.debertz.logic.client.redux.state.ErrorState>): void;
-        readonly id: string;
-        readonly table: com.debertz.logic.data.models.table.DebertzTable;
-        readonly isTableExists: boolean;
-        readonly gameLifecycleState: com.debertz.logic.data.models.GameLifecycleState;
+        error(error: Nullable<any>/* Nullable<games.jass.logic.data.models.table.error.ErrorState> */): void;
+        observeGameHistoryEvents(): any/* kotlinx.coroutines.flow.Flow<games.jass.logic.client.data.models.vm.HistoryViewModel> */;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic": unique symbol;
-        } & com.debertz.logic.client.domain.mechanic.GameMechanic["__doNotUseOrImplementIt"];
+            readonly "games.jass.logic.client.domain.mechanic.GameMechanic": unique symbol;
+        } & games.jass.logic.GameStoreContract["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace com.debertz.logic.client.redux.state {
-    class ErrorState {
-        constructor(message: Nullable<string> | undefined, userInfo: Nullable<com.logic.data.models.player.GameUserInfo> | undefined, reason: com.logic.data.models.TerminationGameReason);
-        get message(): Nullable<string>;
-        get userInfo(): Nullable<com.logic.data.models.player.GameUserInfo>;
-        get reason(): com.logic.data.models.TerminationGameReason;
-        copy(message?: Nullable<string>, userInfo?: Nullable<com.logic.data.models.player.GameUserInfo>, reason?: com.logic.data.models.TerminationGameReason): com.debertz.logic.client.redux.state.ErrorState;
-        toString(): string;
-        hashCode(): number;
-        equals(other: Nullable<any>): boolean;
+export declare namespace games.jass.logic.client.domain.mechanic.online {
+    interface OnlineGameMechanic extends games.jass.logic.client.domain.mechanic.GameMechanic {
+        readonly currentPlayerId: string;
+        observeFromClientAction(): any/* kotlinx.coroutines.flow.Flow<games.jass.logic.redux.actions.client.from.FromClientAction> */;
+        mechanicActions(actions: Array<games.jass.logic.redux.actions.mechanic.MechanicAction>): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.jass.logic.client.domain.mechanic.online.OnlineGameMechanic": unique symbol;
+        } & games.jass.logic.client.domain.mechanic.GameMechanic["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace com.debertz.logic.client.utils {
-    interface ShowClientErrorLoggerOutput extends com.logic.utils.logger.outputs.LoggerOutput {
+export declare namespace games.jass.logic.client.utils {
+    interface ShowErrorLoggerOutput extends games.raspberry.logger.output.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;
+        gameClientProvider: Nullable<() => any/* games.jass.logic.client.GameClient */>;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.client.utils.ShowClientErrorLoggerOutput": unique symbol;
-        } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"];
+            readonly "games.jass.logic.client.utils.ShowErrorLoggerOutput": unique symbol;
+        } & games.raspberry.logger.output.LoggerOutput["__doNotUseOrImplementIt"];
     }
 }
 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;
+    createOnlineGameEngine(currentPlayerId: string): games.jass.logic.client.domain.mechanic.online.OnlineGameMechanic;
+    createOnlineGameEngineWithLogic(currentPlayerId: string, reducers?: Array<(p0: any/* games.jass.logic.redux.AppState */, p1: any) => any/* games.jass.logic.redux.AppState */>, middlewares?: Array<(p0: com.logic.redux.store.definitions.Store<any/* games.jass.logic.redux.AppState */>, p1: (p0: com.logic.redux.store.definitions.Action) => void, p2: any) => void>, gameClientConfig?: games.jass.logic.client.data.models.config.GameClientConfig, engineBotConfig?: games.jass.logic.data.models.EngineBotConfig, logicConfig?: games.jass.logic.data.models.EngineLogicConfig, dealerConfig?: games.jass.logic.data.models.DealerConfig, coreConfig?: com.logic.data.models.CoreConfig): games.jass.logic.client.domain.mechanic.online.OnlineGameMechanic;
     readonly __doNotUseOrImplementIt: {
         readonly GameClientEngineController: unique symbol;
     };
 }
 export declare function createGameClientController(loggerCallback: (p0: string, p1: Nullable<string>, p2: string, p3: Nullable<Error>, p4: Nullable<any>) => void): GameClientEngineController;
-export declare namespace com.debertz.logic.server.data.models {
-    class ServerReduxConfig {
-        constructor(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number);
-        get finishGameIfAllBots(): boolean;
-        get waitForPlayerToReconnect(): boolean;
-        get waitForPlayerToReconnectTimeOutMillis(): number;
-        get closeIfBotsAtFinish(): boolean;
-        get botReplacesPlayerAfterTimeout(): boolean;
-        get enabledCombinedEvents(): boolean;
-        get delayToAskBotMillis(): number;
-        copy(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number): com.debertz.logic.server.data.models.ServerReduxConfig;
-        toString(): string;
-        hashCode(): number;
-        equals(other: Nullable<any>): boolean;
-    }
-}
-export declare namespace com.debertz.logic.server.domain {
-    interface ServerGameEngineContract extends com.debertz.logic.GameStoreContract {
-        roomOnCreate(roomId: string, gameCreatorId: string, config: com.debertz.logic.data.models.table.config.Config, users: Array<com.logic.data.models.player.GameUserInfo>): void;
+export declare namespace games.jass.logic.server.domain {
+    interface ServerGameEngineContract extends games.jass.logic.GameStoreContract {
+        roomOnCreate(roomId: string, gameCreatorId: string, config: games.jass.logic.data.models.table.config.Config, users: Array<com.logic.data.models.player.GameUserInfo>): void;
+        roomRefreshPlayerState(playerId: string): void;
         roomOnDelete(): void;
         playerLostConnection(playerId: string): void;
         playerLive(playerId: string): void;
         playerLeft(playerId: string): void;
-        fromClientEvent(action: com.debertz.logic.redux.actions.client.from.FromClientAction): void;
-        subscribeToClientAction(subscriber: (p0: com.debertz.logic.redux.actions.client.to.ToClientAction) => void): void;
-        subscribeWith(subscriber: (p0: any/* com.debertz.logic.redux.AppState */) => void): void;
+        fromClientEvent(action: games.jass.logic.redux.actions.client.from.FromClientAction): void;
+        subscribeToClientAction(subscriber: (p0: games.jass.logic.redux.actions.client.to.ToClientAction) => void): void;
+        subscribeWith(subscriber: (p0: any/* games.jass.logic.redux.AppState */) => void): void;
         clear(): void;
         setCanStartNewGameEnabled(enabled: boolean): void;
         shutdown(reason: string): void;
-        readonly id: string;
-        readonly table: com.debertz.logic.data.models.table.DebertzTable;
-        readonly isTableExists: boolean;
-        readonly gameLifecycleState: com.debertz.logic.data.models.GameLifecycleState;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.server.domain.ServerGameEngineContract": unique symbol;
-        } & com.debertz.logic.GameStoreContract["__doNotUseOrImplementIt"];
+            readonly "games.jass.logic.server.domain.ServerGameEngineContract": unique symbol;
+        } & games.jass.logic.GameStoreContract["__doNotUseOrImplementIt"];
     }
 }
 export declare interface GameHelper {
-    filterLivePlayers(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
-    filterLiveDuringGamePlayers(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
-    filterBotPlayers(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
-    filterRealPlayers(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
-    getUserSocketId(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, playerId: string): Nullable<string>;
-    getUserSocketIds(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>): Nullable<Array<string>>;
-    createConfig(points: number, players: number, timeoutTimeMillis: number, rulesSetType: com.logic.data.models.rules.RulesSetType, rules: any, isEnableChat: boolean, isPrivate: boolean): com.debertz.logic.data.models.table.config.Config;
-    mapPoints(points: number): com.debertz.logic.data.models.table.config.PointsMode;
-    mapPlayers(players: number): com.debertz.logic.data.models.table.config.PlayersMode;
-    mapRules(rules: any): com.logic.data.models.rules.Rules;
+    filterLivePlayers(store: com.logic.redux.store.definitions.Store<any/* games.jass.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
+    filterLiveDuringGamePlayers(store: com.logic.redux.store.definitions.Store<any/* games.jass.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
+    filterBotPlayers(store: com.logic.redux.store.definitions.Store<any/* games.jass.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
+    filterRealPlayers(store: com.logic.redux.store.definitions.Store<any/* games.jass.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
+    getUserSocketId(store: com.logic.redux.store.definitions.Store<any/* games.jass.logic.redux.AppState */>, playerId: string): Nullable<string>;
+    getUserSocketIds(store: com.logic.redux.store.definitions.Store<any/* games.jass.logic.redux.AppState */>): Nullable<Array<string>>;
+    createConfig(points: number, players: number, timeoutTimeMillis: number, rulesSetType: games.jass.logic.data.models.rules.RulesSetType, rules: any, isEnableChat: boolean, isBotsEnabled: boolean, isPrivate: boolean): games.jass.logic.data.models.table.config.Config;
+    mapToRoomConfig(config: games.jass.logic.data.models.table.config.Config): models.RoomConfig;
+    mapPoints(points: number): games.jass.logic.data.models.table.config.PointsMode;
+    mapPlayers(players: number): games.jass.logic.data.models.table.config.PlayersMode;
+    mapRules(rules: any): games.jass.logic.data.models.rules.Rules;
     prepareConfigObjectWithPagination(config: any): any;
     prepareConfigObject(config: any): any;
     isValidConfigObject(config: any): boolean;
     isValidConfig(players: number, points: number, timeoutTime: number, rulesPreset: string, rules: any): boolean;
-    getRulesByType(rulesSetType: com.logic.data.models.rules.RulesSetType): com.logic.data.models.rules.Rules;
-    getRulesByString(name: string): com.logic.data.models.rules.Rules;
-    mapRulesSetType(name: string): com.logic.data.models.rules.RulesSetType;
+    getRulesByType(rulesSetType: games.jass.logic.data.models.rules.RulesSetType): games.jass.logic.data.models.rules.Rules;
+    getRulesByString(name: string): games.jass.logic.data.models.rules.Rules;
+    mapRulesSetType(name: string): games.jass.logic.data.models.rules.RulesSetType;
     readonly __doNotUseOrImplementIt: {
         readonly GameHelper: unique symbol;
     };
@@ -980,18 +1896,19 @@ export declare interface GameEngineController {
     readonly test: TestHelper;
     readonly helper: GameHelper;
     readonly resources: GameResources;
+    readonly randomPoolProvider: any/* games.raspberry.card_game.random.data.providers.RandomPoolProvider */;
     setEnableLogger(enabled: boolean): void;
-    createGameEngine(): com.debertz.logic.server.domain.ServerGameEngineContract;
-    createGameEngineWithLogic(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>, serverConfig?: com.debertz.logic.server.data.models.ServerReduxConfig, logicConfig?: com.debertz.logic.data.models.LogicReduxConfig): com.debertz.logic.server.domain.ServerGameEngineContract;
+    createGameEngine(): games.jass.logic.server.domain.ServerGameEngineContract;
+    createGameEngineWithLogic(reducers?: Array<(p0: any/* games.jass.logic.redux.AppState */, p1: any) => any/* games.jass.logic.redux.AppState */>, middlewares?: Array<(p0: com.logic.redux.store.definitions.Store<any/* games.jass.logic.redux.AppState */>, p1: (p0: com.logic.redux.store.definitions.Action) => void, p2: any) => void>, serverConfig?: games.jass.logic.data.models.config.ServerReduxConfig, logicConfig?: games.jass.logic.data.models.EngineLogicConfig, dealerConfig?: games.jass.logic.data.models.DealerConfig, coreConfig?: com.logic.data.models.CoreConfig): games.jass.logic.server.domain.ServerGameEngineContract;
     readonly __doNotUseOrImplementIt: {
         readonly GameEngineController: unique symbol;
     };
 }
-export declare function createGameServerController(loggerCallback: (p0: string, p1: Nullable<string>, p2: string, p3: Nullable<Error>, p4: Nullable<any>) => void): GameEngineController;
+export declare function createGameServerController(loggerCallback: (p0: string, p1: Nullable<string>, p2: string, p3: Nullable<Error>, p4: Nullable<any>) => void, randomOrgConfig?: games.raspberry.card_game.random.data.models.RandomOrgConfig): GameEngineController;
 export declare interface TestHelper {
-    getPlayerAnswer(table: com.debertz.logic.data.models.table.DebertzTable, playerId: string, botConfig: com.debertz.logic.data.models.BotReduxConfig): com.debertz.logic.redux.actions.client.from.FromClientAction;
-    getPlayerAnswerFromClientAction(table: com.debertz.logic.data.models.table.DebertzTable, currentPlayerId: string, action: com.debertz.logic.redux.actions.client.to.ToClientAction, botConfig: com.debertz.logic.data.models.BotReduxConfig): Nullable<com.debertz.logic.redux.actions.client.from.FromClientAction>;
-    getPlayerAnswerFromMechanicAction(table: com.debertz.logic.data.models.table.DebertzTable, currentPlayerId: string, action: com.debertz.logic.redux.actions.mechanic.MechanicAction, botConfig: com.debertz.logic.data.models.BotReduxConfig): Nullable<com.debertz.logic.redux.actions.client.from.FromClientAction>;
+    getPlayerAnswer(table: games.jass.logic.data.models.table.JassTable, playerId: string, botConfig: games.jass.logic.data.models.EngineBotConfig): games.jass.logic.redux.actions.client.from.FromClientAction;
+    getPlayerAnswerFromClientAction(table: games.jass.logic.data.models.table.JassTable, currentPlayerId: string, action: games.jass.logic.redux.actions.client.to.ToClientAction, botConfig: games.jass.logic.data.models.EngineBotConfig): Nullable<games.jass.logic.redux.actions.client.from.FromClientAction>;
+    getPlayerAnswerFromMechanicAction(table: games.jass.logic.data.models.table.JassTable, currentPlayerId: string, action: games.jass.logic.redux.actions.mechanic.MechanicAction, botConfig: games.jass.logic.data.models.EngineBotConfig): Nullable<games.jass.logic.redux.actions.client.from.FromClientAction>;
     readonly __doNotUseOrImplementIt: {
         readonly TestHelper: unique symbol;
     };
@@ -1046,4 +1963,4 @@ export declare interface EnginesControllerWeb {
     };
 }
 export declare function createEnginesControllerWeb(): EnginesControllerWeb;
-export as namespace Logic_Debertz_client_plugin;
+export as namespace io_raspberryapps_game_engine_client_plugin;