game_client_logic_deb 1.8.117 → 1.8.144

package/Logic_Debertz-game_client.d.ts

@@ -6,12 +6,6 @@ export declare namespace kotlin.collections {
             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: {
@@ -51,6 +45,8 @@ export declare namespace io.raspberryapps.card_game.core.utils.logger.output {
         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 "io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput": unique symbol;
         };
@@ -82,42 +78,46 @@ export declare namespace com.logic.data.models {
 export declare namespace com.logic.data.models {
     abstract class TerminationGameReason {
         protected constructor();
-        static get Companion(): {
-        } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
-    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
-    class PlayerLostConnectionReason extends com.logic.data.models.TerminationGameReason /* implements com.logic.data.models.FinishPlayerReason */ {
+    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;
-        static get Companion(): {
-        };
+        readonly __doNotUseOrImplementIt: com.logic.data.models.FinishPlayerReason["__doNotUseOrImplementIt"];
     }
-    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
-    class PlayerTimeoutReason extends com.logic.data.models.TerminationGameReason /* implements com.logic.data.models.FinishPlayerReason */ {
+    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;
-        static get Companion(): {
-        };
+        readonly __doNotUseOrImplementIt: com.logic.data.models.FinishPlayerReason["__doNotUseOrImplementIt"];
     }
-    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
-    class PlayerExitReason extends com.logic.data.models.TerminationGameReason /* implements com.logic.data.models.FinishPlayerReason */ {
+    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;
-        static get Companion(): {
+        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;
         };
     }
-    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
     class GameFinishedReason extends com.logic.data.models.TerminationGameReason {
         constructor(reason: com.logic.data.models.GameFinishedReason.Reason);
         get reason(): com.logic.data.models.GameFinishedReason.Reason;
@@ -125,8 +125,6 @@ export declare namespace com.logic.data.models {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
     }
     namespace GameFinishedReason {
         abstract class Reason {
@@ -155,7 +153,6 @@ export declare namespace com.logic.data.models {
             } & any/* kotlinx.serialization.internal.SerializerFactory */;
         }
     }
-    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
     class GameErrorReason extends com.logic.data.models.TerminationGameReason {
         constructor(reason: com.logic.data.models.GameErrorReason.Reason);
         get reason(): com.logic.data.models.GameErrorReason.Reason;
@@ -163,8 +160,6 @@ export declare namespace com.logic.data.models {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
     }
     namespace GameErrorReason {
         abstract class Reason {
@@ -185,8 +180,12 @@ export declare namespace com.logic.data.models {
                 get name(): "WRONG_PLAYER_TURN";
                 get ordinal(): 3;
             };
-            get name(): "SERVER_ERROR" | "INTERNAL_ERROR" | "GAME_NOT_EXISTS" | "WRONG_PLAYER_TURN";
-            get ordinal(): 0 | 1 | 2 | 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(): {
@@ -197,12 +196,12 @@ export declare namespace com.logic.data.models {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-    } & com.logic.data.models.TerminationGameReason & any/* kotlinx.serialization.internal.SerializerFactory */;
+    } & com.logic.data.models.TerminationGameReason;
     const ProcessingReason: {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-    } & com.logic.data.models.TerminationGameReason & any/* kotlinx.serialization.internal.SerializerFactory */;
+    } & com.logic.data.models.TerminationGameReason;
 }
 export declare namespace com.logic.data.models.player {
     class GameUserInfo implements com.logic.data.models.player.PlayerIdContract {
@@ -275,104 +274,6 @@ export declare namespace com.logic.data.models.player {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
-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;
-        toString(): string;
-        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;
-        hashCode(): number;
-        equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-            kharkiv(): com.logic.data.models.rules.Rules;
-            saltivka(): 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();
-        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 debertzSaltivka(): com.logic.data.models.rules.RulesSetType & {
-            get name(): "debertzSaltivka";
-            get ordinal(): 4;
-        };
-        static get custom(): com.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(): com.logic.data.models.rules.Rules;
-        get isCustom(): boolean;
-        static values(): Array<com.logic.data.models.rules.RulesSetType>;
-        static valueOf(value: string): com.logic.data.models.rules.RulesSetType;
-    }
-}
-export declare namespace com.logic.data.models.serializable.rules {
-    class RulesDto {
-        constructor(needToPutHigherTrump: Nullable<boolean> | undefined, distributePoints: Nullable<boolean> | undefined, protectBella: Nullable<boolean> | undefined, oneTryToProtectBella: Nullable<boolean> | undefined, enableFourSevensCombination: Nullable<boolean> | undefined, enableTrumpSevenCombination: Nullable<boolean> | undefined, enableTrumpSevenCombinationAfterDistribution: Nullable<boolean> | undefined, playerWhoChooseSuitGoFirst: Nullable<boolean> | undefined, winnerShuffleCards: Nullable<boolean> | undefined, playWithoutLiabilities: Nullable<boolean> | undefined, trumpCardGoToPlayerWhoShuffleCards: Nullable<boolean> | undefined, enableFineIfNoBribes: Nullable<boolean> | undefined, fineIfNoBribes: number, enableFineAfterThirdByte?: Nullable<boolean>, checkTrumpCombination?: Nullable<boolean>, checkOnlyTrumpDebertz?: Nullable<boolean>, tenCardsInHand?: Nullable<boolean>);
-        get needToPutHigherTrump(): Nullable<boolean>;
-        get distributePoints(): Nullable<boolean>;
-        get protectBella(): Nullable<boolean>;
-        get oneTryToProtectBella(): Nullable<boolean>;
-        get enableFourSevensCombination(): Nullable<boolean>;
-        get enableTrumpSevenCombination(): Nullable<boolean>;
-        get enableTrumpSevenCombinationAfterDistribution(): Nullable<boolean>;
-        get playerWhoChooseSuitGoFirst(): Nullable<boolean>;
-        get winnerShuffleCards(): Nullable<boolean>;
-        get playWithoutLiabilities(): Nullable<boolean>;
-        get trumpCardGoToPlayerWhoShuffleCards(): Nullable<boolean>;
-        get enableFineIfNoBribes(): Nullable<boolean>;
-        get fineIfNoBribes(): number;
-        get enableFineAfterThirdByte(): Nullable<boolean>;
-        get checkTrumpCombination(): Nullable<boolean>;
-        get checkOnlyTrumpDebertz(): Nullable<boolean>;
-        get tenCardsInHand(): Nullable<boolean>;
-        copy(needToPutHigherTrump?: Nullable<boolean>, distributePoints?: Nullable<boolean>, protectBella?: Nullable<boolean>, oneTryToProtectBella?: Nullable<boolean>, enableFourSevensCombination?: Nullable<boolean>, enableTrumpSevenCombination?: Nullable<boolean>, enableTrumpSevenCombinationAfterDistribution?: Nullable<boolean>, playerWhoChooseSuitGoFirst?: Nullable<boolean>, winnerShuffleCards?: Nullable<boolean>, playWithoutLiabilities?: Nullable<boolean>, trumpCardGoToPlayerWhoShuffleCards?: Nullable<boolean>, enableFineIfNoBribes?: Nullable<boolean>, fineIfNoBribes?: number, enableFineAfterThirdByte?: Nullable<boolean>, checkTrumpCombination?: Nullable<boolean>, checkOnlyTrumpDebertz?: Nullable<boolean>, tenCardsInHand?: Nullable<boolean>): com.logic.data.models.serializable.rules.RulesDto;
-        toString(): string;
-        hashCode(): number;
-        equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
-    }
-}
 export declare namespace com.logic.redux.actions {
     interface BufferedAction extends com.logic.redux.store.definitions.Action {
         readonly __doNotUseOrImplementIt: {
@@ -441,8 +342,16 @@ export declare namespace com.logic.utils.logger.outputs {
             get name(): "WARN";
             get ordinal(): 2;
         };
-        get name(): "DEBUG" | "ERROR" | "WARN";
-        get ordinal(): 0 | 1 | 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;
         static get Companion(): {
@@ -471,153 +380,188 @@ 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 com.debertz.logic.data.models {
+export declare namespace games.jass.logic.data.models {
     class DealerConfig {
-        constructor(dealerStrategy?: com.debertz.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean, cards?: Nullable<Array<number>>);
-        get dealerStrategy(): com.debertz.logic.domain.interactors.dealer.DealerStrategy;
+        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?: com.debertz.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean, cards?: Nullable<Array<number>>): com.debertz.logic.data.models.DealerConfig;
+        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, cards?: Nullable<Array<number>>): com.debertz.logic.data.models.DealerConfig;
-            fake(cards?: Array<number>): com.debertz.logic.data.models.DealerConfig;
+            getFromServerConfig(dealerStrategy?: string, cards?: Nullable<Array<number>>): games.jass.logic.data.models.DealerConfig;
+            fake(cards?: Array<number>): games.jass.logic.data.models.DealerConfig;
         };
     }
 }
-export declare namespace com.debertz.logic.data.models {
+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.EngineBotConfig;
+        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);
+        constructor(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number);
         get supportBackwardActions(): boolean;
         get validateTestMode(): boolean;
         get verboseGameHistory(): boolean;
-        copy(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean): com.debertz.logic.data.models.EngineLogicConfig;
+        get validateFromClientActionTags(): boolean;
+        get playerTimeoutFactorToFinishStep(): number;
+        copy(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number): games.jass.logic.data.models.EngineLogicConfig;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         static get Companion(): {
-            getClientEngineTestMode(): com.debertz.logic.data.models.EngineLogicConfig;
-            getServerEngineMode(isProduction: boolean, supportBackwardActions?: boolean): com.debertz.logic.data.models.EngineLogicConfig;
+            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 com.debertz.logic.data.models {
+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;
         };
         get name(): "CREATED" | "CREATING" | "FINISHING" | "FINISHED";
         get ordinal(): 0 | 1 | 2 | 3;
-        static values(): Array<com.debertz.logic.data.models.GameLifecycleState>;
-        static valueOf(value: string): com.debertz.logic.data.models.GameLifecycleState;
+        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 {
+export declare namespace games.jass.logic.data.models {
     class GameSessionAnalytics {
-        constructor(duration: any/* kotlin.time.Duration */, gamesCount: number, roundsCountTotal: number, playerAnalytics: kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.PlayerAnalytics>);
+        constructor(duration: any/* kotlin.time.Duration */, gamesCount: number, roundsCountTotal: number, playerAnalytics: kotlin.collections.KtList<games.jass.logic.data.models.player.hand.PlayerAnalytics>);
         get duration(): any/* kotlin.time.Duration */;
         get gamesCount(): number;
         get roundsCountTotal(): number;
-        get playerAnalytics(): kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.PlayerAnalytics>;
-        get allCombinationCounts(): Array<com.debertz.logic.data.models.CombinationPair>;
-        copy(duration?: any/* kotlin.time.Duration */, gamesCount?: number, roundsCountTotal?: number, playerAnalytics?: kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.PlayerAnalytics>): com.debertz.logic.data.models.GameSessionAnalytics;
+        get playerAnalytics(): kotlin.collections.KtList<games.jass.logic.data.models.player.hand.PlayerAnalytics>;
+        get allCombinationCounts(): Array<games.jass.logic.data.models.CombinationPair>;
+        copy(duration?: any/* kotlin.time.Duration */, gamesCount?: number, roundsCountTotal?: number, playerAnalytics?: kotlin.collections.KtList<games.jass.logic.data.models.player.hand.PlayerAnalytics>): games.jass.logic.data.models.GameSessionAnalytics;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
     class CombinationPair {
-        constructor(combinationType: com.debertz.logic.data.models.table.combinations.CombinationType, count: number);
-        get combinationType(): com.debertz.logic.data.models.table.combinations.CombinationType;
+        constructor(combinationType: games.jass.logic.data.models.table.combinations.CombinationType, count: number);
+        get combinationType(): games.jass.logic.data.models.table.combinations.CombinationType;
         get count(): number;
-        copy(combinationType?: com.debertz.logic.data.models.table.combinations.CombinationType, count?: number): com.debertz.logic.data.models.CombinationPair;
+        copy(combinationType?: 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 com.debertz.logic.data.models.player.hand {
+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: com.debertz.logic.data.models.table.combinations.CombinationType, state: com.debertz.logic.data.models.table.combinations.CombinationState, value: number);
+        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(): com.debertz.logic.data.models.table.combinations.CombinationType;
-        get state(): com.debertz.logic.data.models.table.combinations.CombinationState;
+        get type(): games.jass.logic.data.models.table.combinations.CombinationType;
+        get state(): games.jass.logic.data.models.table.combinations.CombinationState;
         get value(): number;
-        copy(id?: string, type?: com.debertz.logic.data.models.table.combinations.CombinationType, state?: com.debertz.logic.data.models.table.combinations.CombinationState, value?: number): com.debertz.logic.data.models.player.hand.CombinationRecord;
+        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.player.hand {
+export declare namespace games.jass.logic.data.models.player.hand {
     class PlayerAnalytics implements com.logic.data.models.player.PlayerIdContract {
-        constructor(playerId: string, factor: number, wasLiveDuringGame: boolean, liveDurationPercentage: Nullable<number>, combinationRecords: kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.CombinationRecord>);
+        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<com.debertz.logic.data.models.player.hand.CombinationRecord>;
-        get combinationCounts(): kotlin.collections.KtMap<com.debertz.logic.data.models.table.combinations.CombinationType, number>;
-        copy(playerId?: string, factor?: number, wasLiveDuringGame?: boolean, liveDurationPercentage?: Nullable<number>, combinationRecords?: kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.CombinationRecord>): com.debertz.logic.data.models.player.hand.PlayerAnalytics;
+        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>;
+        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.hand.PlayerAnalytics;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace com.debertz.logic.data.models.player.state {
+export declare namespace games.jass.logic.data.models.player.state {
     abstract class RoundContractState {
         private constructor();
-        static get FAILED(): com.debertz.logic.data.models.player.state.RoundContractState & {
+        static get FAILED(): games.jass.logic.data.models.player.state.RoundContractState & {
             get name(): "FAILED";
             get ordinal(): 0;
         };
-        static get FULFILLED(): com.debertz.logic.data.models.player.state.RoundContractState & {
+        static get FULFILLED(): games.jass.logic.data.models.player.state.RoundContractState & {
             get name(): "FULFILLED";
             get ordinal(): 1;
         };
-        static get CONTROVERSIAL(): com.debertz.logic.data.models.player.state.RoundContractState & {
+        static get CONTROVERSIAL(): games.jass.logic.data.models.player.state.RoundContractState & {
             get name(): "CONTROVERSIAL";
             get ordinal(): 2;
         };
@@ -626,70 +570,176 @@ export declare namespace com.debertz.logic.data.models.player.state {
         get isFailed(): boolean;
         get isFulfilled(): boolean;
         get isControversial(): boolean;
-        static values(): Array<com.debertz.logic.data.models.player.state.RoundContractState>;
-        static valueOf(value: string): com.debertz.logic.data.models.player.state.RoundContractState;
+        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 com.debertz.logic.data.models.scenes {
+export declare namespace games.jass.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, 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>);
+        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 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>;
+        toString(): string;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        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, 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>): 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: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.player.DebertzPlayer */>, sceneInfo: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.table.bribes.CardOnTable */>, bribes: kotlin.collections.KtList<any/* 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 */, gameHistory: com.debertz.logic.data.models.table.history.GameHistory);
+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(): kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.player.DebertzPlayer */>;
-        get sceneInfo(): any/* com.debertz.logic.data.models.table.scene.SceneInfo */;
-        get cardsOnTable(): kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.table.bribes.CardOnTable */>;
-        get bribes(): kotlin.collections.KtList<any/* 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 gameHistory(): com.debertz.logic.data.models.table.history.GameHistory;
+        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 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 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?: com.debertz.logic.data.models.table.config.Config, players?: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.player.DebertzPlayer */>, sceneInfo?: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable?: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.table.bribes.CardOnTable */>, bribes?: kotlin.collections.KtList<any/* 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 */, gameHistory?: com.debertz.logic.data.models.table.history.GameHistory): com.debertz.logic.data.models.table.DebertzTable;
+        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(tableId: string, gameId: string, version: string, config: com.debertz.logic.data.models.table.config.Config, players: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* 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 {
+export declare namespace games.jass.logic.data.models.table {
     class TableLoggerPayload implements io.raspberryapps.card_game.core.utils.logger.LoggerPayload {
-        constructor(id: string, gameId: string, players: Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>);
+        constructor(id: string, gameId: string, players: Array<games.jass.logic.data.models.table.PlayerLoggerPayload>);
         get id(): string;
         get gameId(): string;
-        get players(): Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>;
+        get players(): Array<games.jass.logic.data.models.table.PlayerLoggerPayload>;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
         toString(): string;
-        copy(id?: string, gameId?: string, players?: Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>): com.debertz.logic.data.models.table.TableLoggerPayload;
+        copy(id?: string, gameId?: string, players?: Array<games.jass.logic.data.models.table.PlayerLoggerPayload>): games.jass.logic.data.models.table.TableLoggerPayload;
         readonly __doNotUseOrImplementIt: io.raspberryapps.card_game.core.utils.logger.LoggerPayload["__doNotUseOrImplementIt"];
     }
     class PlayerLoggerPayload implements io.raspberryapps.card_game.core.utils.logger.LoggerPayload {
@@ -697,219 +747,253 @@ export declare namespace com.debertz.logic.data.models.table {
         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: io.raspberryapps.card_game.core.utils.logger.LoggerPayload["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace com.debertz.logic.data.models.table.combinations {
-    class Combination /* implements com.debertz.logic.data.models.table.combinations.CombinationContract */ {
-        constructor(id: string, type: com.debertz.logic.data.models.table.combinations.CombinationType, cards: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>);
-        copy(id?: string, type?: com.debertz.logic.data.models.table.combinations.CombinationType, cards?: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>): com.debertz.logic.data.models.table.combinations.Combination;
+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 */>>);
+        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 */>>): games.jass.logic.data.models.table.combinations.Combination;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
 }
-export declare namespace com.debertz.logic.data.models.table.combinations {
+export declare namespace games.jass.logic.data.models.table.combinations {
     abstract class CombinationState {
         private constructor();
-        static get NOT_VERIFIED(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+        static get NOT_VERIFIED(): games.jass.logic.data.models.table.combinations.CombinationState & {
             get name(): "NOT_VERIFIED";
             get ordinal(): 0;
         };
-        static get VERIFYING(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+        static get VERIFYING(): games.jass.logic.data.models.table.combinations.CombinationState & {
             get name(): "VERIFYING";
             get ordinal(): 1;
         };
-        static get ACCEPTED(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+        static get ACCEPTED(): games.jass.logic.data.models.table.combinations.CombinationState & {
             get name(): "ACCEPTED";
             get ordinal(): 2;
         };
-        static get NOT_ACCEPTED(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+        static get NOT_ACCEPTED(): games.jass.logic.data.models.table.combinations.CombinationState & {
             get name(): "NOT_ACCEPTED";
             get ordinal(): 3;
         };
-        static get REJECTED(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+        static get REJECTED(): games.jass.logic.data.models.table.combinations.CombinationState & {
             get name(): "REJECTED";
             get ordinal(): 4;
         };
-        static get CANCELED(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+        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<com.debertz.logic.data.models.table.combinations.CombinationState>;
-        static valueOf(value: string): com.debertz.logic.data.models.table.combinations.CombinationState;
+        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 com.debertz.logic.data.models.table.combinations {
+export declare namespace games.jass.logic.data.models.table.combinations {
     abstract class CombinationType {
         private constructor();
-        static get BELA(): com.debertz.logic.data.models.table.combinations.CombinationType & {
+        static get BELA(): games.jass.logic.data.models.table.combinations.CombinationType & {
             get name(): "BELA";
             get ordinal(): 0;
         };
-        static get THREE_IN_ROW(): com.debertz.logic.data.models.table.combinations.CombinationType & {
+        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(): com.debertz.logic.data.models.table.combinations.CombinationType & {
+        static get FOUR_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
             get name(): "FOUR_IN_ROW";
             get ordinal(): 2;
         };
-        static get SEVEN_IN_ROW(): com.debertz.logic.data.models.table.combinations.CombinationType & {
-            get name(): "SEVEN_IN_ROW";
+        static get FIVE_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FIVE_IN_ROW";
             get ordinal(): 3;
         };
-        static get SEVEN_TRUMP(): com.debertz.logic.data.models.table.combinations.CombinationType & {
-            get name(): "SEVEN_TRUMP";
+        static get SEVEN_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "SEVEN_IN_ROW";
             get ordinal(): 4;
         };
-        static get FOUR_SEVENS(): com.debertz.logic.data.models.table.combinations.CombinationType & {
-            get name(): "FOUR_SEVENS";
+        static get SEVEN_TRUMP(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "SEVEN_TRUMP";
             get ordinal(): 5;
         };
-        static get FINE_NO_BRIBES(): com.debertz.logic.data.models.table.combinations.CombinationType & {
-            get name(): "FINE_NO_BRIBES";
+        static get FOUR_ACES(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_ACES";
             get ordinal(): 6;
         };
-        static get FINE_THIRD_FAILED_CONTRACT(): com.debertz.logic.data.models.table.combinations.CombinationType & {
-            get name(): "FINE_THIRD_FAILED_CONTRACT";
+        static get FOUR_KINGS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_KINGS";
             get ordinal(): 7;
         };
-        static get BONUS_LAST_BRIBE(): com.debertz.logic.data.models.table.combinations.CombinationType & {
-            get name(): "BONUS_LAST_BRIBE";
+        static get FOUR_DAMES(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_DAMES";
             get ordinal(): 8;
         };
-        static get BONUS_FAILED_CONTRACT(): com.debertz.logic.data.models.table.combinations.CombinationType & {
-            get name(): "BONUS_FAILED_CONTRACT";
+        static get FOUR_JACKS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_JACKS";
             get ordinal(): 9;
         };
-        static get BONUS_CONTROVERSIAL_CONTRACT(): com.debertz.logic.data.models.table.combinations.CombinationType & {
-            get name(): "BONUS_CONTROVERSIAL_CONTRACT";
+        static get FOUR_TENS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_TENS";
             get ordinal(): 10;
         };
-        get name(): "BELA" | "THREE_IN_ROW" | "FOUR_IN_ROW" | "SEVEN_IN_ROW" | "SEVEN_TRUMP" | "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;
-        static values(): Array<com.debertz.logic.data.models.table.combinations.CombinationType>;
-        static valueOf(value: string): com.debertz.logic.data.models.table.combinations.CombinationType;
+        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(): {
-            getSupportedInRowCardsCombinations(): kotlin.collections.KtSet<number>;
+            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 com.debertz.logic.data.models.table.combinations {
+export declare namespace games.jass.logic.data.models.table.combinations {
     class PlayerCombinations implements com.logic.data.models.player.PlayerIdContract {
-        constructor(playerId: string, combinations: Array<com.debertz.logic.data.models.table.combinations.Combination>);
+        constructor(playerId: string, combinations: Array<games.jass.logic.data.models.table.combinations.Combination>);
         get playerId(): string;
-        get combinations(): Array<com.debertz.logic.data.models.table.combinations.Combination>;
+        get combinations(): Array<games.jass.logic.data.models.table.combinations.Combination>;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        copy(playerId?: string, combinations?: Array<com.debertz.logic.data.models.table.combinations.Combination>): com.debertz.logic.data.models.table.combinations.PlayerCombinations;
+        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 com.debertz.logic.data.models.table.config {
+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;
         };
         get name(): "SUPER_HARD" | "HARD" | "MEDIUM" | "EASY" | "SUPER_EASY";
         get ordinal(): 0 | 1 | 2 | 3 | 4;
-        static values(): Array<com.debertz.logic.data.models.table.config.BotIntelligenceLevel>;
-        static valueOf(value: string): com.debertz.logic.data.models.table.config.BotIntelligenceLevel;
+        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?: 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;
+        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 com.debertz.logic.data.models.table.config {
+export declare namespace games.jass.logic.data.models.table.config {
     class ConfigLite {
-        constructor(players: com.debertz.logic.data.models.table.config.PlayersMode, points: com.debertz.logic.data.models.table.config.PointsMode, timeoutTimeMillis: number, rulesPreset: com.logic.data.models.rules.RulesSetType, isPrivate: boolean, isChatEnabled: boolean, rules: Nullable<com.logic.data.models.rules.Rules>);
-        get players(): com.debertz.logic.data.models.table.config.PlayersMode;
-        get points(): com.debertz.logic.data.models.table.config.PointsMode;
+        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(): com.logic.data.models.rules.RulesSetType;
+        get rulesPreset(): games.jass.logic.data.models.rules.RulesSetType;
         get isPrivate(): boolean;
         get isChatEnabled(): boolean;
-        get rules(): Nullable<com.logic.data.models.rules.Rules>;
-        copy(players?: com.debertz.logic.data.models.table.config.PlayersMode, points?: com.debertz.logic.data.models.table.config.PointsMode, timeoutTimeMillis?: number, rulesPreset?: com.logic.data.models.rules.RulesSetType, isPrivate?: boolean, isChatEnabled?: boolean, rules?: Nullable<com.logic.data.models.rules.Rules>): com.debertz.logic.data.models.table.config.ConfigLite;
+        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);
+        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;
-        copy(isEnableChat?: boolean, botIntelligenceLevel?: com.debertz.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: 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();
-        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;
         };
@@ -918,114 +1002,118 @@ export declare namespace com.debertz.logic.data.models.table.config {
         get value(): number;
         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;
+        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();
-        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;
         };
         get name(): "SMALL" | "MEDIUM" | "BIG" | "TEST";
         get ordinal(): 0 | 1 | 2 | 3;
         get value(): number;
-        static values(): Array<com.debertz.logic.data.models.table.config.PointsMode>;
-        static valueOf(value: string): com.debertz.logic.data.models.table.config.PointsMode;
+        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.data.models.table.history {
+export declare namespace games.jass.logic.data.models.table.history {
     class GameHistory {
-        constructor(gameId: string, createdAt: any/* kotlinx.datetime.Instant */, rounds: Array<com.debertz.logic.data.models.table.history.RoundHistory>);
+        constructor(gameId: string, createdAt: any/* kotlinx.datetime.Instant */, rounds: Array<games.jass.logic.data.models.table.history.RoundHistory>);
         get gameId(): string;
         get createdAt(): any/* kotlinx.datetime.Instant */;
-        get rounds(): Array<com.debertz.logic.data.models.table.history.RoundHistory>;
+        get rounds(): Array<games.jass.logic.data.models.table.history.RoundHistory>;
         get date(): string;
-        get lastRoundHistory(): com.debertz.logic.data.models.table.history.RoundHistory;
+        get lastRoundHistory(): games.jass.logic.data.models.table.history.RoundHistory;
         get isFirstRound(): boolean;
         get roundsCount(): number;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
         toString(): string;
-        copy(gameId?: string, createdAt?: any/* kotlinx.datetime.Instant */, rounds?: Array<com.debertz.logic.data.models.table.history.RoundHistory>): com.debertz.logic.data.models.table.history.GameHistory;
+        copy(gameId?: string, createdAt?: any/* kotlinx.datetime.Instant */, rounds?: Array<games.jass.logic.data.models.table.history.RoundHistory>): games.jass.logic.data.models.table.history.GameHistory;
         static get Companion(): {
-            initial(gameId: string, createdAt?: any/* kotlinx.datetime.Instant */): com.debertz.logic.data.models.table.history.GameHistory;
+            initial(gameId: string, createdAt?: any/* kotlinx.datetime.Instant */): games.jass.logic.data.models.table.history.GameHistory;
         };
     }
 }
-export declare namespace com.debertz.logic.data.models.table.history {
+export declare namespace games.jass.logic.data.models.table.history {
     class RoundHistory {
-        constructor(roundNumber: number, items: Array<com.debertz.logic.data.models.table.history.RoundHistoryItem>);
+        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<com.debertz.logic.data.models.table.history.RoundHistoryItem>;
+        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>;
         get isRoundEmpty(): boolean;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
         toStringShort(): string;
-        copy(roundNumber?: number, items?: Array<com.debertz.logic.data.models.table.history.RoundHistoryItem>): com.debertz.logic.data.models.table.history.RoundHistory;
+        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): com.debertz.logic.data.models.table.history.RoundHistory;
+            initial(roundNumber: number): games.jass.logic.data.models.table.history.RoundHistory;
         };
     }
 }
-export declare namespace com.debertz.logic.data.models.table.history {
+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 com.debertz.logic.domain.interactors.dealer {
+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;
         };
         get name(): "FAKE" | "BASED_ON_PREVIOUS" | "EQUAL_HAND_BY_POINTS" | "EQUAL_HAND_BY_VALUE" | "RANDOM";
         get ordinal(): 0 | 1 | 2 | 3 | 4;
         shouldEqualiseHand(): boolean;
-        static values(): Array<com.debertz.logic.domain.interactors.dealer.DealerStrategy>;
-        static valueOf(value: string): com.debertz.logic.domain.interactors.dealer.DealerStrategy;
+        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;
@@ -1036,7 +1124,7 @@ export declare namespace com.debertz.logic.redux.actions {
         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 {
+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;
@@ -1045,103 +1133,99 @@ export declare namespace com.debertz.logic.redux.actions.client.from {
         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(id: string, includePlayers: Array<string>, excludePlayers: Array<string>, deliveryType: com.debertz.logic.redux.actions.client.to.ActionDeliveryType);
+        constructor(id: string, includePlayers: Array<string>, excludePlayers: Array<string>, deliveryType: games.jass.logic.redux.actions.client.to.ActionDeliveryType);
         get id(): 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;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
         toString(): string;
-        copy(id?: string, includePlayers?: Array<string>, excludePlayers?: Array<string>, deliveryType?: com.debertz.logic.redux.actions.client.to.ActionDeliveryType): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
+        copy(id?: 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(): {
-            userFromTable(table: com.debertz.logic.data.models.table.DebertzTable, sendToPlayerId: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
-            user(tableId: string, sendToPlayerId: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
+            userFromTable(table: games.jass.logic.data.models.table.JassTable, sendToPlayerId: string): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
+            user(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;
         };
         get name(): "ROOM_ALL" | "ROOM_EXCEPT_USER" | "USER";
         get ordinal(): 0 | 1 | 2;
-        static values(): Array<com.debertz.logic.redux.actions.client.to.ActionDeliveryType>;
-        static valueOf(value: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryType;
+        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 {
+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.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace com.debertz.logic.redux.actions.game {
+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.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
-    class RoundStartedAction extends com.debertz.logic.redux.actions.game.GameAction {
-        constructor(id: string, gameId: string, roundNumber: number, players: Array<string>, isFirstRound: boolean, gameNumber: number, gameHistory: com.debertz.logic.data.models.table.history.GameHistory);
+    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 isFirstRound(): boolean;
         get gameNumber(): number;
-        get gameHistory(): com.debertz.logic.data.models.table.history.GameHistory;
+        get gameHistory(): games.jass.logic.data.models.table.history.GameHistory;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
         toString(): string;
-        copy(id?: string, gameId?: string, roundNumber?: number, players?: Array<string>, isFirstRound?: boolean, gameNumber?: number, gameHistory?: com.debertz.logic.data.models.table.history.GameHistory): com.debertz.logic.redux.actions.game.RoundStartedAction;
+        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 RoundEndedAction extends com.debertz.logic.redux.actions.game.GameAction {
-        constructor(id: string, gameId: string, roundNumber: number, earnedBiggestPointPlayerId: string, roundCommitted: Array<string>, roundContractState: com.debertz.logic.data.models.player.state.RoundContractState, roundWinners: Array<string>, gameLosers: Nullable<Array<string>> | undefined, gameWinners: Nullable<Array<string>> | undefined, playersGameAnalytics: Nullable<Array<com.debertz.logic.data.models.player.hand.PlayerAnalytics>> | undefined, playersRoundAnalytics: Nullable<Array<com.debertz.logic.data.models.player.hand.PlayerAnalytics>> | undefined, gameHistory: com.debertz.logic.data.models.table.history.GameHistory);
+    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.hand.PlayerAnalytics>> | undefined, playersRoundAnalytics: Nullable<Array<games.jass.logic.data.models.player.hand.PlayerAnalytics>> | undefined, gameHistory: games.jass.logic.data.models.table.history.GameHistory);
         get id(): string;
         get gameId(): string;
         get roundNumber(): number;
         get earnedBiggestPointPlayerId(): string;
-        get roundCommitted(): Array<string>;
-        get roundContractState(): com.debertz.logic.data.models.player.state.RoundContractState;
-        get roundWinners(): Array<string>;
         get gameLosers(): Nullable<Array<string>>;
         get gameWinners(): Nullable<Array<string>>;
-        get playersGameAnalytics(): Nullable<Array<com.debertz.logic.data.models.player.hand.PlayerAnalytics>>;
-        get playersRoundAnalytics(): Nullable<Array<com.debertz.logic.data.models.player.hand.PlayerAnalytics>>;
-        get gameHistory(): com.debertz.logic.data.models.table.history.GameHistory;
-        get roundContractStateName(): string;
+        get playersGameAnalytics(): Nullable<Array<games.jass.logic.data.models.player.hand.PlayerAnalytics>>;
+        get playersRoundAnalytics(): Nullable<Array<games.jass.logic.data.models.player.hand.PlayerAnalytics>>;
+        get gameHistory(): games.jass.logic.data.models.table.history.GameHistory;
         get isGameFinished(): boolean;
         toString(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        copy(id?: string, gameId?: string, roundNumber?: number, earnedBiggestPointPlayerId?: string, roundCommitted?: Array<string>, roundContractState?: com.debertz.logic.data.models.player.state.RoundContractState, roundWinners?: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>, playersGameAnalytics?: Nullable<Array<com.debertz.logic.data.models.player.hand.PlayerAnalytics>>, playersRoundAnalytics?: Nullable<Array<com.debertz.logic.data.models.player.hand.PlayerAnalytics>>, gameHistory?: com.debertz.logic.data.models.table.history.GameHistory): com.debertz.logic.redux.actions.game.RoundEndedAction;
+        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.hand.PlayerAnalytics>>, playersRoundAnalytics?: Nullable<Array<games.jass.logic.data.models.player.hand.PlayerAnalytics>>, gameHistory?: games.jass.logic.data.models.table.history.GameHistory): games.jass.logic.redux.actions.game.RoundEndedAction;
         get actionTag(): string;
     }
     class PartyRestartedAction implements com.logic.redux.store.definitions.Action {
         constructor(id: string, roundNumber: number);
         get id(): string;
         get partyNumber(): number;
-        copy(id?: string, roundNumber?: 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;
@@ -1149,7 +1233,7 @@ export declare namespace com.debertz.logic.redux.actions.game {
         readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
-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();
         get actionTag(): string;
@@ -1159,94 +1243,94 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         readonly id: string;
         readonly version: string;
         readonly users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>;
-        readonly config: com.debertz.logic.data.models.table.config.Config;
+        readonly config: games.jass.logic.data.models.table.config.Config;
         readonly gameCreatorPlayerId: string;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.redux.actions.mechanic.FirstMechanicAction": unique symbol;
+            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 com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.FirstMechanicAction {
-        constructor(config: com.debertz.logic.data.models.table.config.Config, id: string, version: string, gameCreatorPlayerId: string, users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>);
-        get config(): com.debertz.logic.data.models.table.config.Config;
+    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, id: string, version: string, gameCreatorPlayerId: string, users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>);
+        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>;
-        copy(config?: com.debertz.logic.data.models.table.config.Config, id?: string, version?: string, gameCreatorPlayerId?: string, users?: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>): com.debertz.logic.redux.actions.mechanic.StartGameMechanicAction;
+        copy(config?: games.jass.logic.data.models.table.config.Config, id?: string, version?: string, gameCreatorPlayerId?: string, users?: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>): games.jass.logic.redux.actions.mechanic.StartGameMechanicAction;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
-        readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.debertz.logic.redux.actions.mechanic.FirstMechanicAction["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.FirstMechanicAction["__doNotUseOrImplementIt"];
     }
-    class StartNewGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction {
+    class StartNewGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction {
         constructor(previousGameId: string, gameId: string);
         get previousGameId(): string;
         get gameId(): string;
-        copy(previousGameId?: string, gameId?: string): com.debertz.logic.redux.actions.mechanic.StartNewGameMechanicAction;
+        copy(previousGameId?: string, gameId?: 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 com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.TerminatedAction {
-        constructor(reason: com.logic.data.models.TerminationGameReason, sessionAnalytics: Nullable<com.debertz.logic.data.models.GameSessionAnalytics> | undefined, isGameFinished: boolean, gameHistory?: Nullable<com.debertz.logic.data.models.table.history.GameHistory>);
+    class FinishingGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements games.jass.logic.redux.actions.mechanic.TerminatedAction {
+        constructor(reason: com.logic.data.models.TerminationGameReason, sessionAnalytics: Nullable<games.jass.logic.data.models.GameSessionAnalytics> | undefined, isGameFinished: boolean, gameHistory?: Nullable<games.jass.logic.data.models.table.history.GameHistory>);
         get reason(): com.logic.data.models.TerminationGameReason;
-        get sessionAnalytics(): Nullable<com.debertz.logic.data.models.GameSessionAnalytics>;
+        get sessionAnalytics(): Nullable<games.jass.logic.data.models.GameSessionAnalytics>;
         get isGameFinished(): boolean;
-        get gameHistory(): Nullable<com.debertz.logic.data.models.table.history.GameHistory>;
+        get gameHistory(): Nullable<games.jass.logic.data.models.table.history.GameHistory>;
         toString(): string;
-        copy(reason?: com.logic.data.models.TerminationGameReason, sessionAnalytics?: Nullable<com.debertz.logic.data.models.GameSessionAnalytics>, isGameFinished?: boolean, gameHistory?: Nullable<com.debertz.logic.data.models.table.history.GameHistory>): com.debertz.logic.redux.actions.mechanic.FinishingGameMechanicAction;
+        copy(reason?: com.logic.data.models.TerminationGameReason, sessionAnalytics?: Nullable<games.jass.logic.data.models.GameSessionAnalytics>, isGameFinished?: boolean, gameHistory?: Nullable<games.jass.logic.data.models.table.history.GameHistory>): 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"];
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.TerminatedAction["__doNotUseOrImplementIt"];
         static get Companion(): {
-            withAnalytics(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, table: Nullable<com.debertz.logic.data.models.table.DebertzTable>): com.debertz.logic.redux.actions.mechanic.FinishingGameMechanicAction;
+            withAnalytics(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, table: Nullable<games.jass.logic.data.models.table.JassTable>): 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 {
+    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);
         get reason(): com.logic.data.models.TerminationGameReason;
-        copy(reason?: com.logic.data.models.TerminationGameReason): com.debertz.logic.redux.actions.mechanic.FinishGameMechanicAction;
+        copy(reason?: com.logic.data.models.TerminationGameReason): 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.redux.store.definitions.Action {
         readonly sceneId: string;
         readonly actId: Nullable<string>;
-        readonly actData: Nullable<com.debertz.logic.data.models.scenes.ActData>;
+        readonly actData: Nullable<games.jass.logic.data.models.scenes.ActData>;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction": unique symbol;
+            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.redux.store.definitions.Action, com.logic.redux.actions.ReleaseBufferTriggerAction, com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished/*, com.debertz.logic.redux.actions.mechanic.NextPlayerTurnAction */ {
-        constructor(sceneId: string, actId?: Nullable<string>, sceneData?: Nullable<com.debertz.logic.data.models.scenes.SceneData>, actData?: 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>);
         get sceneId(): string;
         get actId(): Nullable<string>;
-        get sceneData(): Nullable<com.debertz.logic.data.models.scenes.SceneData>;
-        get actData(): 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>;
         notValidateWhenFinished(): boolean;
         notValidateWhenFinishing(): boolean;
         toString(): string;
-        copy(sceneId?: string, actId?: Nullable<string>, sceneData?: Nullable<com.debertz.logic.data.models.scenes.SceneData>, actData?: Nullable<com.debertz.logic.data.models.scenes.ActData>): com.debertz.logic.redux.actions.mechanic.SceneMechanicAction;
+        copy(sceneId?: string, actId?: Nullable<string>, sceneData?: Nullable<games.jass.logic.data.models.scenes.SceneData>, actData?: Nullable<games.jass.logic.data.models.scenes.ActData>): 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.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"];
+        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.redux.store.definitions.Action {
         readonly reason: com.logic.data.models.TerminationGameReason;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.redux.actions.mechanic.TerminatedAction": unique symbol;
+            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 {
+    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>);
         get playerId(): string;
         get state(): com.logic.data.models.player.PlayerConnectionState;
@@ -1257,61 +1341,61 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         get isDeleted(): boolean;
         get shouldNotifyPlayers(): boolean;
         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>): com.debertz.logic.redux.actions.mechanic.PlayerConnectionChangedMechanicAction;
+        copy(playerId?: string, state?: com.logic.data.models.player.PlayerConnectionState, causeState?: Nullable<com.logic.data.models.player.PlayerConnectionState>, isNoneActivePlayers?: boolean, reconnectUntilTime?: 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;
-    decodeToClientEventToMechanicActions(playerId: string, engine: com.debertz.logic.GameStoreContract, json: string): Array<com.debertz.logic.redux.actions.mechanic.MechanicAction>;
-    encodeGameRound(round: com.debertz.logic.data.models.table.history.RoundHistory): string;
-    encodeGameRoundItems(round: com.debertz.logic.data.models.table.history.RoundHistory): string;
+    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;
     readonly __doNotUseOrImplementIt: {
         readonly ParserHelper: unique symbol;
     };
 }
-export declare namespace com.debertz.logic.client.data.models.config {
+export declare namespace games.jass.logic.client.data.models.config {
     abstract class GameType {
         private constructor();
-        static get SINGLE(): com.debertz.logic.client.data.models.config.GameType & {
+        static get SINGLE(): games.jass.logic.client.data.models.config.GameType & {
             get name(): "SINGLE";
             get ordinal(): 0;
         };
-        static get SERVER(): com.debertz.logic.client.data.models.config.GameType & {
+        static get SERVER(): games.jass.logic.client.data.models.config.GameType & {
             get name(): "SERVER";
             get ordinal(): 1;
         };
-        static get P2P_CLIENT(): com.debertz.logic.client.data.models.config.GameType & {
+        static get P2P_CLIENT(): games.jass.logic.client.data.models.config.GameType & {
             get name(): "P2P_CLIENT";
             get ordinal(): 2;
         };
-        static get P2P_SERVER(): com.debertz.logic.client.data.models.config.GameType & {
+        static get P2P_SERVER(): games.jass.logic.client.data.models.config.GameType & {
             get name(): "P2P_SERVER";
             get ordinal(): 3;
         };
-        static get TUTORIAL(): com.debertz.logic.client.data.models.config.GameType & {
+        static get TUTORIAL(): games.jass.logic.client.data.models.config.GameType & {
             get name(): "TUTORIAL";
             get ordinal(): 4;
         };
         get name(): "SINGLE" | "SERVER" | "P2P_CLIENT" | "P2P_SERVER" | "TUTORIAL";
         get ordinal(): 0 | 1 | 2 | 3 | 4;
-        static values(): Array<com.debertz.logic.client.data.models.config.GameType>;
-        static valueOf(value: string): com.debertz.logic.client.data.models.config.GameType;
+        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 com.debertz.logic.client.data.models.config {
+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;
@@ -1320,105 +1404,105 @@ export declare namespace com.debertz.logic.client.data.models.config {
         get isAutoStepCurrentPlayer(): boolean;
         get areOpponentsCardsOpened(): boolean;
         get sessionAnalytics(): boolean;
-        copy(validateSceneActiveState?: boolean, validateCardOnMove?: boolean, validateExpectantActions?: boolean, isAutoStepCurrentPlayer?: boolean, areOpponentsCardsOpened?: boolean, sessionAnalytics?: boolean): com.debertz.logic.client.data.models.config.GameClientConfig;
+        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(): com.debertz.logic.client.data.models.config.GameClientConfig;
+            getClientEngineTestMode(): games.jass.logic.client.data.models.config.GameClientConfig;
         };
     }
 }
-export declare namespace com.debertz.logic.client.data.models.vm {
-    class GameHistoryViewModel /* extends com.debertz.logic.client.data.models.vm.HistoryViewModel */ {
-        constructor(gameId: string, createdAt: any/* kotlinx.datetime.Instant */, gameType: com.debertz.logic.client.data.models.config.GameType, users: Array<com.logic.data.models.player.GameUserInfo>, config: com.debertz.logic.data.models.table.config.ConfigLite, gameWinners: Nullable<Array<string>>);
+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>>);
         get gameId(): string;
         get createdAt(): any/* kotlinx.datetime.Instant */;
-        get gameType(): com.debertz.logic.client.data.models.config.GameType;
+        get gameType(): games.jass.logic.client.data.models.config.GameType;
         get users(): Array<com.logic.data.models.player.GameUserInfo>;
-        get config(): com.debertz.logic.data.models.table.config.ConfigLite;
+        get config(): games.jass.logic.data.models.table.config.ConfigLite;
         get gameWinners(): Nullable<Array<string>>;
         toString(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        copy(gameId?: string, createdAt?: any/* kotlinx.datetime.Instant */, gameType?: com.debertz.logic.client.data.models.config.GameType, users?: Array<com.logic.data.models.player.GameUserInfo>, config?: com.debertz.logic.data.models.table.config.ConfigLite, gameWinners?: Nullable<Array<string>>): com.debertz.logic.client.data.models.vm.GameHistoryViewModel;
+        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>>): games.jass.logic.client.data.models.vm.GameHistoryViewModel;
     }
-    class RoundEndedHistoryViewModel /* extends com.debertz.logic.client.data.models.vm.HistoryViewModel */ {
-        constructor(gameId: string, roundNumber: number, items: Array<com.debertz.logic.data.models.table.history.RoundHistoryItem>, roundContractState: com.debertz.logic.data.models.player.state.RoundContractState, roundCommitted: Array<string>, roundWinners: Array<string>, gameEndedHistory: Nullable<com.debertz.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<com.debertz.logic.data.models.table.history.RoundHistoryItem>;
-        get roundContractState(): com.debertz.logic.data.models.player.state.RoundContractState;
-        get roundCommitted(): Array<string>;
-        get roundWinners(): Array<string>;
-        get gameEndedHistoryViewModel(): Nullable<com.debertz.logic.client.data.models.vm.GameHistoryViewModel>;
+        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<com.debertz.logic.data.models.table.history.RoundHistoryItem>, roundContractState?: com.debertz.logic.data.models.player.state.RoundContractState, roundCommitted?: Array<string>, roundWinners?: Array<string>, gameEndedHistory?: Nullable<com.debertz.logic.client.data.models.vm.GameHistoryViewModel>): com.debertz.logic.client.data.models.vm.RoundEndedHistoryViewModel;
+        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 com.debertz.logic.client.domain.mechanic {
-    interface GameMechanic extends com.debertz.logic.GameStoreContract/*, com.debertz.logic.client.domain.scenes.PlayersSceneContract */ {
+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> */;
+        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<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> */;
+        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.data.models.table.error.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<any>/* Nullable<com.debertz.logic.data.models.table.error.ErrorState> */): void;
-        observeGameHistoryEvents(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.vm.HistoryViewModel> */;
+        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.GameMechanic": unique symbol;
-        } & com.debertz.logic.GameStoreContract["__doNotUseOrImplementIt"];
+            readonly "games.jass.logic.client.domain.mechanic.GameMechanic": unique symbol;
+        } & games.jass.logic.GameStoreContract["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace com.debertz.logic.client.domain.mechanic.online {
-    interface OnlineGameMechanic extends com.debertz.logic.client.domain.mechanic.GameMechanic {
+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<com.debertz.logic.redux.actions.client.from.FromClientAction> */;
-        mechanicActions(actions: Array<com.debertz.logic.redux.actions.mechanic.MechanicAction>): void;
+        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 "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.online.OnlineGameMechanic": unique symbol;
+        } & games.jass.logic.client.domain.mechanic.GameMechanic["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace com.debertz.logic.client.utils {
+export declare namespace games.jass.logic.client.utils {
     interface ShowErrorLoggerOutput extends io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput {
         skipWarnings: boolean;
-        gameClientProvider: Nullable<() => any/* com.debertz.logic.client.GameClient */>;
+        gameClientProvider: Nullable<() => any/* games.jass.logic.client.GameClient */>;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.debertz.logic.client.utils.ShowErrorLoggerOutput": unique symbol;
+            readonly "games.jass.logic.client.utils.ShowErrorLoggerOutput": unique symbol;
         } & io.raspberryapps.card_game.core.utils.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.redux.store.definitions.Store<any/* com.debertz.logic.redux.AppState */>, p1: (p0: com.logic.redux.store.definitions.Action) => void, p2: any) => void>, gameClientConfig?: com.debertz.logic.client.data.models.config.GameClientConfig, engineBotConfig?: com.debertz.logic.data.models.EngineBotConfig, logicConfig?: com.debertz.logic.data.models.EngineLogicConfig, dealerConfig?: com.debertz.logic.data.models.DealerConfig, coreConfig?: com.logic.data.models.CoreConfig): 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;
     };