game_client_logic_deb 1.8.147 → 1.8.185

package/Logic_Debertz-game_client.d.ts

@@ -6,6 +6,12 @@ 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: {
@@ -13,34 +19,29 @@ export declare namespace kotlin.collections {
         };
     }
 }
-export declare namespace io.raspberryapps.cardgame.core {
-    const CoreConfig: {
-        get version(): string;
-    };
-}
-export declare namespace io.raspberryapps.card_game.core.utils.logger {
-    interface LoggerEnabledTrigger extends io.raspberryapps.card_game.core.utils.logger.RaspberryLogger {
+export declare namespace games.raspberry.logger {
+    interface LoggerEnabledTrigger extends games.raspberry.logger.RaspberryLogger {
         enabled: boolean;
         readonly __doNotUseOrImplementIt: {
-            readonly "io.raspberryapps.card_game.core.utils.logger.LoggerEnabledTrigger": unique symbol;
-        } & io.raspberryapps.card_game.core.utils.logger.RaspberryLogger["__doNotUseOrImplementIt"];
+            readonly "games.raspberry.logger.LoggerEnabledTrigger": unique symbol;
+        } & games.raspberry.logger.RaspberryLogger["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace io.raspberryapps.card_game.core.utils.logger {
+export declare namespace games.raspberry.logger {
     interface LoggerPayload {
         readonly __doNotUseOrImplementIt: {
-            readonly "io.raspberryapps.card_game.core.utils.logger.LoggerPayload": unique symbol;
+            readonly "games.raspberry.logger.LoggerPayload": unique symbol;
         };
     }
 }
-export declare namespace io.raspberryapps.card_game.core.utils.logger {
-    interface RaspberryLogger extends io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput {
+export declare namespace games.raspberry.logger {
+    interface RaspberryLogger extends games.raspberry.logger.output.LoggerOutput {
         readonly __doNotUseOrImplementIt: {
-            readonly "io.raspberryapps.card_game.core.utils.logger.RaspberryLogger": unique symbol;
-        } & io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput["__doNotUseOrImplementIt"];
+            readonly "games.raspberry.logger.RaspberryLogger": unique symbol;
+        } & games.raspberry.logger.output.LoggerOutput["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace io.raspberryapps.card_game.core.utils.logger.output {
+export declare namespace games.raspberry.logger.output {
     interface LoggerOutput {
         d(tag: Nullable<string> | undefined, message: string, payload?: Nullable<any>): void;
         e(tag?: Nullable<string>, message?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
@@ -48,9 +49,93 @@ export declare namespace io.raspberryapps.card_game.core.utils.logger.output {
         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;
+            readonly "games.raspberry.logger.output.LoggerOutput": unique symbol;
+        };
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class CardDecksRequestUserData {
+        constructor(id: string, count: number);
+        get id(): string;
+        get count(): number;
+        copy(id?: string, count?: number): games.raspberry.card_game.random.data.models.CardDecksRequestUserData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    class CardDeckRequestUserData {
+        constructor(players: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.UserInfoData>, gameId: string);
+        get players(): kotlin.collections.KtList<games.raspberry.card_game.random.data.models.UserInfoData>;
+        get gameId(): string;
+        copy(players?: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.UserInfoData>, gameId?: string): games.raspberry.card_game.random.data.models.CardDeckRequestUserData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    class UserInfoData {
+        constructor(id: string, name: string);
+        get id(): string;
+        get name(): string;
+        copy(id?: string, name?: string): games.raspberry.card_game.random.data.models.UserInfoData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class GameCardDecksRecord {
+        constructor(id: string, signature: Nullable<string>, userData: games.raspberry.card_game.random.data.models.CardDeckRequestUserData, rounds?: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.GameCardDeckData>);
+        get id(): string;
+        get signature(): Nullable<string>;
+        get userData(): games.raspberry.card_game.random.data.models.CardDeckRequestUserData;
+        get rounds(): kotlin.collections.KtList<games.raspberry.card_game.random.data.models.GameCardDeckData>;
+        copy(id?: string, signature?: Nullable<string>, userData?: games.raspberry.card_game.random.data.models.CardDeckRequestUserData, rounds?: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.GameCardDeckData>): games.raspberry.card_game.random.data.models.GameCardDecksRecord;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            firstRound(id: string, signature: Nullable<string>, newCardDeckData: games.raspberry.card_game.random.data.models.GameCardDeckData, userData: games.raspberry.card_game.random.data.models.CardDeckRequestUserData): games.raspberry.card_game.random.data.models.GameCardDecksRecord;
+            newRound(gameCardDecksRecord: games.raspberry.card_game.random.data.models.GameCardDecksRecord, newCardDeckData: games.raspberry.card_game.random.data.models.GameCardDeckData): games.raspberry.card_game.random.data.models.GameCardDecksRecord;
         };
     }
+    class GameCardDeckData {
+        constructor(cardDeckIndex: number, cards: kotlin.collections.KtList<number>);
+        get cardDeckIndex(): number;
+        get cards(): kotlin.collections.KtList<number>;
+        copy(cardDeckIndex?: number, cards?: kotlin.collections.KtList<number>): games.raspberry.card_game.random.data.models.GameCardDeckData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class HttpConfig {
+        constructor(baseUrl: string, timeoutMillis?: number);
+        get baseUrl(): string;
+        get timeoutMillis(): number;
+        copy(baseUrl?: string, timeoutMillis?: number): games.raspberry.card_game.random.data.models.HttpConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class RandomOrgConfig {
+        constructor(apiKey?: string, poolSize?: number, thresholdForUsedPool?: number, httpConfig?: games.raspberry.card_game.random.data.models.HttpConfig);
+        get apiKey(): string;
+        get poolSize(): number;
+        get thresholdForUsedPool(): number;
+        get httpConfig(): games.raspberry.card_game.random.data.models.HttpConfig;
+        copy(apiKey?: string, poolSize?: number, thresholdForUsedPool?: number, httpConfig?: games.raspberry.card_game.random.data.models.HttpConfig): games.raspberry.card_game.random.data.models.RandomOrgConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace io.raspberryapps.cardgame.core {
+    const CoreConfig: {
+        get version(): string;
+    };
 }
 export declare namespace com.logic {
     const GameEngineConfig: {
@@ -359,20 +444,22 @@ export declare namespace com.logic.utils.logger.outputs {
     }
 }
 export declare namespace com.logic.utils.logger.outputs {
-    interface ObservableLoggerOutput extends io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput, io.raspberryapps.card_game.core.utils.logger.LoggerEnabledTrigger {
+    interface ObservableLoggerOutput extends games.raspberry.logger.output.LoggerOutput, games.raspberry.logger.LoggerEnabledTrigger {
+        payloadToKeyMapper: (p0: Nullable<any>) => Nullable<string>;
         observe(types?: Array<com.logic.utils.logger.outputs.LogType>): any/* kotlinx.coroutines.flow.Flow<com.logic.utils.logger.outputs.LoggerOutputDataDto> */;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.utils.logger.outputs.ObservableLoggerOutput": unique symbol;
-        } & io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput["__doNotUseOrImplementIt"] & io.raspberryapps.card_game.core.utils.logger.LoggerEnabledTrigger["__doNotUseOrImplementIt"];
+        } & games.raspberry.logger.output.LoggerOutput["__doNotUseOrImplementIt"] & games.raspberry.logger.LoggerEnabledTrigger["__doNotUseOrImplementIt"];
     }
     class LoggerOutputDataDto {
-        constructor(type: com.logic.utils.logger.outputs.LogType, tag: Nullable<string>, message: Nullable<string>, stackTrace: Nullable<string>);
+        constructor(type: com.logic.utils.logger.outputs.LogType, key: Nullable<string>, tag: Nullable<string>, message: Nullable<string>, stackTrace: Nullable<string>);
         get type(): com.logic.utils.logger.outputs.LogType;
+        get key(): Nullable<string>;
         get tag(): Nullable<string>;
         get message(): Nullable<string>;
         get stackTrace(): Nullable<string>;
         toMessageLog(): string;
-        copy(type?: com.logic.utils.logger.outputs.LogType, tag?: Nullable<string>, message?: Nullable<string>, stackTrace?: Nullable<string>): com.logic.utils.logger.outputs.LoggerOutputDataDto;
+        copy(type?: com.logic.utils.logger.outputs.LogType, key?: Nullable<string>, tag?: Nullable<string>, message?: Nullable<string>, stackTrace?: Nullable<string>): com.logic.utils.logger.outputs.LoggerOutputDataDto;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -402,7 +489,7 @@ export declare namespace games.jass.logic.data.models {
         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>>): games.jass.logic.data.models.DealerConfig;
+            getFromServerConfig(dealerStrategy?: string, cardsJson?: Nullable<string>): games.jass.logic.data.models.DealerConfig;
             fake(cards?: Array<number>): games.jass.logic.data.models.DealerConfig;
         };
     }
@@ -422,13 +509,14 @@ export declare namespace games.jass.logic.data.models {
 }
 export declare namespace games.jass.logic.data.models {
     class EngineLogicConfig {
-        constructor(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number);
+        constructor(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, gameHistoryAnalytics?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number);
         get supportBackwardActions(): boolean;
         get validateTestMode(): boolean;
         get verboseGameHistory(): boolean;
+        get gameHistoryMetadata(): boolean;
         get validateFromClientActionTags(): boolean;
         get playerTimeoutFactorToFinishStep(): number;
-        copy(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number): games.jass.logic.data.models.EngineLogicConfig;
+        copy(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, gameHistoryAnalytics?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number): games.jass.logic.data.models.EngineLogicConfig;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -467,23 +555,175 @@ export declare namespace games.jass.logic.data.models {
 }
 export declare namespace games.jass.logic.data.models {
     class GameSessionAnalytics {
-        constructor(duration: any/* kotlin.time.Duration */, gamesCount: number, roundsCountTotal: number, handsCount: number, playerAnalytics: kotlin.collections.KtList<games.jass.logic.data.models.player.hand.PlayerAnalytics>);
+        constructor(duration: any/* kotlin.time.Duration */, gamesCount: number, roundsCountTotal: number, handsCount: number, playerAnalytics: Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>);
         get duration(): any/* kotlin.time.Duration */;
         get gamesCount(): number;
         get roundsCountTotal(): number;
         get handsCount(): number;
-        get playerAnalytics(): kotlin.collections.KtList<games.jass.logic.data.models.player.hand.PlayerAnalytics>;
+        get playerAnalytics(): Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>;
         get allCombinationCounts(): Array<games.jass.logic.data.models.CombinationPair>;
-        copy(duration?: any/* kotlin.time.Duration */, gamesCount?: number, roundsCountTotal?: number, handsCount?: number, playerAnalytics?: kotlin.collections.KtList<games.jass.logic.data.models.player.hand.PlayerAnalytics>): games.jass.logic.data.models.GameSessionAnalytics;
+        get allCombinationsAnalytics(): games.jass.logic.data.models.player.analytics.CombinationsAnalytics;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        toString(): string;
+        copy(duration?: any/* kotlin.time.Duration */, gamesCount?: number, roundsCountTotal?: number, handsCount?: number, playerAnalytics?: Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>): games.jass.logic.data.models.GameSessionAnalytics;
+    }
+    class CombinationPair {
+        constructor(type: games.jass.logic.data.models.table.combinations.CombinationType, count: number);
+        get type(): games.jass.logic.data.models.table.combinations.CombinationType;
+        get count(): number;
+        copy(type?: games.jass.logic.data.models.table.combinations.CombinationType, count?: number): games.jass.logic.data.models.CombinationPair;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
-    class CombinationPair {
-        constructor(combinationType: games.jass.logic.data.models.table.combinations.CombinationType, count: number);
-        get combinationType(): games.jass.logic.data.models.table.combinations.CombinationType;
+}
+export declare namespace games.jass.logic.data.models.config {
+    class ServerReduxConfig {
+        constructor(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsPeriod?: number);
+        get finishGameIfAllBots(): boolean;
+        get waitForPlayerToReconnect(): boolean;
+        get waitForPlayerToReconnectTimeOutMillis(): number;
+        get closeIfBotsAtFinish(): boolean;
+        get botReplacesPlayerAfterTimeout(): boolean;
+        get enabledCombinedEvents(): boolean;
+        get delayToAskBotMillis(): number;
+        get combinedEventsPeriod(): number;
+        copy(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsPeriod?: number): games.jass.logic.data.models.config.ServerReduxConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            get DELAY_TO_BUFFER_EVENTS_MILLIS(): number;
+            getServerEngineMode(finishGameIfAllBots: boolean, botReplacesPlayerAfterTimeout: boolean, closeIfBotsAtFinish: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number): games.jass.logic.data.models.config.ServerReduxConfig;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.dealer {
+    class RandomData {
+        constructor(signature: Nullable<string>, id: string, indexes: kotlin.collections.KtList<number>);
+        get signature(): Nullable<string>;
+        get id(): string;
+        get indexes(): kotlin.collections.KtList<number>;
+    }
+}
+export declare namespace games.jass.logic.data.models.messages.combinatios {
+    abstract class CombinationReason /* implements kotlin.Comparable<games.jass.logic.data.models.messages.combinatios.CombinationReason> */ {
+        private constructor();
+        static get WIN_SINGLE_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_SINGLE_COMBINATION";
+            get ordinal(): 0;
+        };
+        static get WIN_HIGHER_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_HIGHER_COMBINATION";
+            get ordinal(): 1;
+        };
+        static get WIN_HIGHER_CARD_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_HIGHER_CARD_COMBINATION";
+            get ordinal(): 2;
+        };
+        static get WIN_TRUMP_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_TRUMP_COMBINATION";
+            get ordinal(): 3;
+        };
+        static get WIN_HIGHER_PLAYER_NUMBER_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_HIGHER_PLAYER_NUMBER_COMBINATION";
+            get ordinal(): 4;
+        };
+        static get WIN_PARTNER_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_PARTNER_COMBINATION";
+            get ordinal(): 5;
+        };
+        static get REJECTED_NOT_TRUMP_SEVEN_IN_ROW_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "REJECTED_NOT_TRUMP_SEVEN_IN_ROW_COMBINATION";
+            get ordinal(): 6;
+        };
+        get name(): "WIN_SINGLE_COMBINATION" | "WIN_HIGHER_COMBINATION" | "WIN_HIGHER_CARD_COMBINATION" | "WIN_TRUMP_COMBINATION" | "WIN_HIGHER_PLAYER_NUMBER_COMBINATION" | "WIN_PARTNER_COMBINATION" | "REJECTED_NOT_TRUMP_SEVEN_IN_ROW_COMBINATION";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        static values(): Array<games.jass.logic.data.models.messages.combinatios.CombinationReason>;
+        static valueOf(value: string): games.jass.logic.data.models.messages.combinatios.CombinationReason;
+    }
+}
+export declare namespace games.jass.logic.data.models.player {
+    class UserProfilePayload {
+        constructor(socketId?: Nullable<string>, rating?: Nullable<number>, playedGamesCount?: number);
+        get socketId(): Nullable<string>;
+        get rating(): Nullable<number>;
+        get playedGamesCount(): number;
+        copy(socketId?: Nullable<string>, rating?: Nullable<number>, playedGamesCount?: number): games.jass.logic.data.models.player.UserProfilePayload;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.achievements {
+    class Achievements {
+        constructor(oldRating: number, newRating: number);
+        get oldRating(): number;
+        get newRating(): number;
+        copy(oldRating?: number, newRating?: number): games.jass.logic.data.models.player.achievements.Achievements;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.achievements {
+    class PlayerAchievements implements com.logic.data.models.player.PlayerIdContract {
+        constructor(playerId: string, oldRating: number, newRating: number);
+        get playerId(): string;
+        get oldRating(): number;
+        get newRating(): number;
+        copy(playerId?: string, oldRating?: number, newRating?: number): games.jass.logic.data.models.player.achievements.PlayerAchievements;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.player.analytics {
+    class CombinationsAnalytics {
+        constructor(combinations: Array<games.jass.logic.data.models.player.analytics.CombinationAnalytics>);
+        get combinations(): Array<games.jass.logic.data.models.player.analytics.CombinationAnalytics>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(combinations?: Array<games.jass.logic.data.models.player.analytics.CombinationAnalytics>): games.jass.logic.data.models.player.analytics.CombinationsAnalytics;
+        toString(): string;
+    }
+    class CombinationAnalytics {
+        constructor(type: games.jass.logic.data.models.table.combinations.CombinationType, count: number, acceptedCounts: number);
+        get type(): games.jass.logic.data.models.table.combinations.CombinationType;
         get count(): number;
-        copy(combinationType?: games.jass.logic.data.models.table.combinations.CombinationType, count?: number): games.jass.logic.data.models.CombinationPair;
+        get acceptedCounts(): number;
+        copy(type?: games.jass.logic.data.models.table.combinations.CombinationType, count?: number, acceptedCounts?: number): games.jass.logic.data.models.player.analytics.CombinationAnalytics;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.analytics {
+    class PlayerAnalytics implements com.logic.data.models.player.PlayerIdContract {
+        constructor(playerId: string, factor: number, wasLiveDuringGame: boolean, liveDurationPercentage: Nullable<number>, combinationRecords: kotlin.collections.KtList<games.jass.logic.data.models.player.hand.CombinationRecord>);
+        get playerId(): string;
+        get factor(): number;
+        get wasLiveDuringGame(): boolean;
+        get liveDurationPercentage(): Nullable<number>;
+        get combinationRecords(): kotlin.collections.KtList<games.jass.logic.data.models.player.hand.CombinationRecord>;
+        get combinationCounts(): kotlin.collections.KtMap<games.jass.logic.data.models.table.combinations.CombinationType, number>;
+        get combinationsAnalytics(): games.jass.logic.data.models.player.analytics.CombinationsAnalytics;
+        toString(): string;
+        copy(playerId?: string, factor?: number, wasLiveDuringGame?: boolean, liveDurationPercentage?: Nullable<number>, combinationRecords?: kotlin.collections.KtList<games.jass.logic.data.models.player.hand.CombinationRecord>): games.jass.logic.data.models.player.analytics.PlayerAnalytics;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.player.analytics {
+    class PlayerHistoryAnalytics /* implements games.jass.logic.data.models.table.history.PlayerHistoryItem */ {
+        constructor(playerId: string, liveDurationPercentage: Nullable<number>, combinations: Nullable<kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.CombinationAnalytics>>, achievements: Nullable<games.jass.logic.data.models.player.achievements.Achievements>);
+        get liveDurationPercentage(): Nullable<number>;
+        get combinations(): Nullable<kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.CombinationAnalytics>>;
+        get achievements(): Nullable<games.jass.logic.data.models.player.achievements.Achievements>;
+        copy(playerId?: string, liveDurationPercentage?: Nullable<number>, combinations?: Nullable<kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.CombinationAnalytics>>, achievements?: Nullable<games.jass.logic.data.models.player.achievements.Achievements>): games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -529,28 +769,13 @@ export declare namespace games.jass.logic.data.models.player.hand {
         get type(): games.jass.logic.data.models.table.combinations.CombinationType;
         get state(): games.jass.logic.data.models.table.combinations.CombinationState;
         get value(): number;
+        get isAccepted(): boolean;
         copy(id?: string, type?: games.jass.logic.data.models.table.combinations.CombinationType, state?: games.jass.logic.data.models.table.combinations.CombinationState, value?: number): games.jass.logic.data.models.player.hand.CombinationRecord;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
 }
-export declare namespace 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<games.jass.logic.data.models.player.hand.CombinationRecord>);
-        get playerId(): string;
-        get factor(): number;
-        get wasLiveDuringGame(): boolean;
-        get liveDurationPercentage(): Nullable<number>;
-        get combinationRecords(): kotlin.collections.KtList<games.jass.logic.data.models.player.hand.CombinationRecord>;
-        get combinationCounts(): kotlin.collections.KtMap<games.jass.logic.data.models.table.combinations.CombinationType, number>;
-        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 games.jass.logic.data.models.player.state {
     abstract class RoundContractState {
         private constructor();
@@ -607,33 +832,34 @@ export declare namespace games.jass.logic.data.models.player.state {
 }
 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>);
+        constructor(needToPutHigherTrump: boolean, playerWhoChooseSuitGoFirst: boolean, winnerShuffleCards: boolean, playWithoutLiabilities: boolean, trumpCardGoToPlayerWhoShuffleCards: boolean, dealerInitialCardsCount: number, dealerFinalCardsCount: number, dealerCounterClockwise: boolean, contractTypes: Array<games.jass.logic.data.models.player.state.RoundContractType>, bidTypes: Array<games.jass.logic.data.models.player.bids.BidType>, combinationsWithFirstCard: Array<games.jass.logic.data.models.table.combinations.CombinationType>, protectBella: boolean, oneTryToProtectBella: boolean, enableFourSevensCombination: boolean, enableTrumpSevenCombination: boolean, enableTrumpSevenCombinationAfterDistribution: boolean, checkTrumpCombination: boolean, checkOnlyTrumpDebertz: boolean, distributePoints: boolean, enableFineAfterThirdFailedContract: boolean, fineAfterThirdFailedContract: number, enableFineIfNoBribes: boolean, fineIfNoBribes: number);
         get needToPutHigherTrump(): boolean;
-        get 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>;
+        get protectBella(): boolean;
+        get oneTryToProtectBella(): boolean;
+        get enableFourSevensCombination(): boolean;
+        get enableTrumpSevenCombination(): boolean;
+        get enableTrumpSevenCombinationAfterDistribution(): boolean;
+        get checkTrumpCombination(): boolean;
+        get checkOnlyTrumpDebertz(): boolean;
+        get distributePoints(): boolean;
+        get enableFineAfterThirdByte(): boolean;
+        get fineAfterThirdFailedContract(): number;
+        get enableFineIfNoBribes(): boolean;
+        get fineIfNoBribes(): number;
         toString(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        copy(needToPutHigherTrump?: boolean, 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;
+        copy(needToPutHigherTrump?: boolean, playerWhoChooseSuitGoFirst?: boolean, winnerShuffleCards?: boolean, playWithoutLiabilities?: boolean, trumpCardGoToPlayerWhoShuffleCards?: boolean, dealerInitialCardsCount?: number, dealerFinalCardsCount?: number, dealerCounterClockwise?: boolean, contractTypes?: Array<games.jass.logic.data.models.player.state.RoundContractType>, bidTypes?: Array<games.jass.logic.data.models.player.bids.BidType>, combinationsWithFirstCard?: Array<games.jass.logic.data.models.table.combinations.CombinationType>, protectBella?: boolean, oneTryToProtectBella?: boolean, enableFourSevensCombination?: boolean, enableTrumpSevenCombination?: boolean, enableTrumpSevenCombinationAfterDistribution?: boolean, checkTrumpCombination?: boolean, checkOnlyTrumpDebertz?: boolean, distributePoints?: boolean, enableFineAfterThirdFailedContract?: boolean, fineAfterThirdFailedContract?: number, enableFineIfNoBribes?: boolean, fineIfNoBribes?: number): games.jass.logic.data.models.rules.Rules;
         static get Companion(): {
             get HAND_CARDS_INITIAL(): number;
             get HAND_CARDS_FINAL(): number;
@@ -732,7 +958,7 @@ export declare namespace games.jass.logic.data.models.table {
     }
 }
 export declare namespace games.jass.logic.data.models.table {
-    class TableLoggerPayload implements io.raspberryapps.card_game.core.utils.logger.LoggerPayload {
+    class TableLoggerPayload implements games.raspberry.logger.LoggerPayload {
         constructor(id: string, gameId: string, players: Array<games.jass.logic.data.models.table.PlayerLoggerPayload>);
         get id(): string;
         get gameId(): string;
@@ -741,9 +967,9 @@ export declare namespace games.jass.logic.data.models.table {
         hashCode(): number;
         toString(): string;
         copy(id?: string, gameId?: string, players?: Array<games.jass.logic.data.models.table.PlayerLoggerPayload>): games.jass.logic.data.models.table.TableLoggerPayload;
-        readonly __doNotUseOrImplementIt: io.raspberryapps.card_game.core.utils.logger.LoggerPayload["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: games.raspberry.logger.LoggerPayload["__doNotUseOrImplementIt"];
     }
-    class PlayerLoggerPayload implements io.raspberryapps.card_game.core.utils.logger.LoggerPayload {
+    class PlayerLoggerPayload implements games.raspberry.logger.LoggerPayload {
         constructor(playerId: string, connectionState: Nullable<com.logic.data.models.player.PlayerConnectionState>);
         get playerId(): string;
         get connectionState(): Nullable<com.logic.data.models.player.PlayerConnectionState>;
@@ -751,14 +977,14 @@ export declare namespace games.jass.logic.data.models.table {
         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"];
+        readonly __doNotUseOrImplementIt: games.raspberry.logger.LoggerPayload["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace games.jass.logic.data.models.table.combinations {
     class Combination /* implements games.jass.logic.data.models.table.combinations.CombinationContract */ {
-        constructor(id: string, type: games.jass.logic.data.models.table.combinations.CombinationType, cards: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>);
-        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;
+        constructor(id: string, type: games.jass.logic.data.models.table.combinations.CombinationType, cards: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>, reasons: kotlin.collections.KtSet<games.jass.logic.data.models.messages.combinatios.CombinationReason>);
         toString(): string;
+        copy(id?: string, type?: games.jass.logic.data.models.table.combinations.CombinationType, cards?: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>, reasons?: kotlin.collections.KtSet<games.jass.logic.data.models.messages.combinatios.CombinationReason>): games.jass.logic.data.models.table.combinations.Combination;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
@@ -1041,23 +1267,39 @@ export declare namespace games.jass.logic.data.models.table.config {
 }
 export declare namespace games.jass.logic.data.models.table.history {
     class GameHistory {
-        constructor(gameId: string, createdAt: any/* kotlinx.datetime.Instant */, rounds: Array<games.jass.logic.data.models.table.history.RoundHistory>);
+        constructor(gameId: string, createdAt: any/* kotlinx.datetime.Instant */, rounds: Array<games.jass.logic.data.models.table.history.RoundHistory>, gameWinners: Nullable<Array<string>>, metadata: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>);
         get gameId(): string;
         get createdAt(): any/* kotlinx.datetime.Instant */;
         get rounds(): Array<games.jass.logic.data.models.table.history.RoundHistory>;
+        get gameWinners(): Nullable<Array<string>>;
+        get metadata(): Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>;
         get date(): string;
         get lastRoundHistory(): games.jass.logic.data.models.table.history.RoundHistory;
         get isFirstRound(): boolean;
         get roundsCount(): number;
+        toString(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        toString(): string;
-        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;
+        copy(gameId?: string, createdAt?: any/* kotlinx.datetime.Instant */, rounds?: Array<games.jass.logic.data.models.table.history.RoundHistory>, gameWinners?: Nullable<Array<string>>, metadata?: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>): games.jass.logic.data.models.table.history.GameHistory;
         static get Companion(): {
             initial(gameId: string, createdAt?: any/* kotlinx.datetime.Instant */): games.jass.logic.data.models.table.history.GameHistory;
         };
     }
 }
+export declare namespace games.jass.logic.data.models.table.history {
+    class GameHistoryMetadata {
+        constructor(randomData: Nullable<games.jass.logic.data.models.dealer.RandomData>, playersAnalytics: kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics>);
+        get randomData(): Nullable<games.jass.logic.data.models.dealer.RandomData>;
+        get playersAnalytics(): kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics>;
+        copy(randomData?: Nullable<games.jass.logic.data.models.dealer.RandomData>, playersAnalytics?: kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics>): games.jass.logic.data.models.table.history.GameHistoryMetadata;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            initial(): games.jass.logic.data.models.table.history.GameHistoryMetadata;
+        };
+    }
+}
 export declare namespace games.jass.logic.data.models.table.history {
     class RoundHistory {
         constructor(roundNumber: number, items: Array<games.jass.logic.data.models.table.history.RoundHistoryItem>, roundCommitted: Nullable<Array<string>>, roundContractState: Nullable<games.jass.logic.data.models.player.state.RoundContractState>, roundWinners: Nullable<Array<string>>);
@@ -1083,6 +1325,23 @@ export declare namespace games.jass.logic.data.models.table.history {
         abstract get createdAt(): any/* kotlinx.datetime.Instant */;
     }
 }
+export declare namespace games.jass.logic.data.models.table.round {
+    class Round {
+        constructor(roundNumber: number, numberOfBribe: Nullable<number>, trump: Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */);
+        get roundNumber(): number;
+        get numberOfBribe(): Nullable<number>;
+        get trump(): Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */;
+        get selectedTrump(): any/* io.raspberryapps.card_game.core.data.models.cards.Suit */;
+        get numberOfBribeOrZero(): number;
+        copy(roundNumber?: number, numberOfBribe?: Nullable<number>, trump?: Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */): games.jass.logic.data.models.table.round.Round;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            initial(): games.jass.logic.data.models.table.round.Round;
+        };
+    }
+}
 export declare namespace games.jass.logic.domain.interactors.dealer {
     abstract class DealerStrategy {
         private constructor();
@@ -1106,8 +1365,16 @@ export declare namespace games.jass.logic.domain.interactors.dealer {
             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;
+        static get RANDOM_ORG(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "RANDOM_ORG";
+            get ordinal(): 5;
+        };
+        static get RANDOM_ORG_SIGNED(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "RANDOM_ORG_SIGNED";
+            get ordinal(): 6;
+        };
+        get name(): "FAKE" | "BASED_ON_PREVIOUS" | "EQUAL_HAND_BY_POINTS" | "EQUAL_HAND_BY_VALUE" | "RANDOM" | "RANDOM_ORG" | "RANDOM_ORG_SIGNED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
         shouldEqualiseHand(): boolean;
         static values(): Array<games.jass.logic.domain.interactors.dealer.DealerStrategy>;
         static valueOf(value: string): games.jass.logic.domain.interactors.dealer.DealerStrategy;
@@ -1197,28 +1464,29 @@ export declare namespace games.jass.logic.redux.actions.game {
         get isFirstRound(): boolean;
         get gameNumber(): number;
         get gameHistory(): games.jass.logic.data.models.table.history.GameHistory;
+        toString(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        toString(): string;
         copy(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 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);
+        constructor(id: string, gameId: string, roundNumber: number, earnedBiggestPointPlayerId: string, gameLosers: Nullable<Array<string>> | undefined, gameWinners: Nullable<Array<string>> | undefined, playersGameAnalytics: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, playersRoundAnalytics: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, achievements: Nullable<Array<games.jass.logic.data.models.player.achievements.PlayerAchievements>>, gameHistory: games.jass.logic.data.models.table.history.GameHistory);
         get id(): string;
         get gameId(): string;
         get roundNumber(): number;
         get earnedBiggestPointPlayerId(): string;
         get gameLosers(): Nullable<Array<string>>;
         get gameWinners(): Nullable<Array<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 playersGameAnalytics(): Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>;
+        get playersRoundAnalytics(): Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>;
+        get achievements(): Nullable<Array<games.jass.logic.data.models.player.achievements.PlayerAchievements>>;
         get gameHistory(): games.jass.logic.data.models.table.history.GameHistory;
         get isGameFinished(): boolean;
         toString(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        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;
+        copy(id?: string, gameId?: string, roundNumber?: number, earnedBiggestPointPlayerId?: string, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>, playersGameAnalytics?: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, playersRoundAnalytics?: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, achievements?: Nullable<Array<games.jass.logic.data.models.player.achievements.PlayerAchievements>>, gameHistory?: games.jass.logic.data.models.table.history.GameHistory): games.jass.logic.redux.actions.game.RoundEndedAction;
         get actionTag(): string;
     }
     class PartyRestartedAction implements com.logic.redux.store.definitions.Action {
@@ -1274,26 +1542,28 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         get actionTag(): string;
     }
     /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
-    class FinishingGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements games.jass.logic.redux.actions.mechanic.TerminatedAction {
-        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>);
+    class FinishingGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements games.jass.logic.redux.actions.mechanic.TerminatedAction, com.logic.redux.actions.validation.NotValidateIfGameFinishing {
+        constructor(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, sessionAnalytics?: Nullable<games.jass.logic.data.models.GameSessionAnalytics>, gameHistory?: Nullable<games.jass.logic.data.models.table.history.GameHistory>);
         get reason(): com.logic.data.models.TerminationGameReason;
-        get sessionAnalytics(): Nullable<games.jass.logic.data.models.GameSessionAnalytics>;
         get isGameFinished(): boolean;
+        get sessionAnalytics(): Nullable<games.jass.logic.data.models.GameSessionAnalytics>;
         get gameHistory(): Nullable<games.jass.logic.data.models.table.history.GameHistory>;
         toString(): string;
-        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;
+        copy(reason?: com.logic.data.models.TerminationGameReason, isGameFinished?: boolean, sessionAnalytics?: Nullable<games.jass.logic.data.models.GameSessionAnalytics>, 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: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.TerminatedAction["__doNotUseOrImplementIt"];
+        notValidateWhenFinishing(): boolean;
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.TerminatedAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"];
         static get Companion(): {
             withAnalytics(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, table: Nullable<games.jass.logic.data.models.table.JassTable>): games.jass.logic.redux.actions.mechanic.FinishingGameMechanicAction;
         };
     }
     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);
+        constructor(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean);
         get reason(): com.logic.data.models.TerminationGameReason;
-        copy(reason?: com.logic.data.models.TerminationGameReason): games.jass.logic.redux.actions.mechanic.FinishGameMechanicAction;
+        get isGameFinished(): boolean;
+        copy(reason?: com.logic.data.models.TerminationGameReason, isGameFinished?: boolean): games.jass.logic.redux.actions.mechanic.FinishGameMechanicAction;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -1326,6 +1596,7 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
     }
     interface TerminatedAction extends com.logic.redux.store.definitions.Action {
         readonly reason: com.logic.data.models.TerminationGameReason;
+        readonly isGameFinished: boolean;
         readonly __doNotUseOrImplementIt: {
             readonly "games.jass.logic.redux.actions.mechanic.TerminatedAction": unique symbol;
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
@@ -1360,10 +1631,28 @@ export declare interface ParserHelper {
     decodeToClientEventToMechanicActions(playerId: string, engine: games.jass.logic.GameStoreContract, json: string): Array<games.jass.logic.redux.actions.mechanic.MechanicAction>;
     encodeGameRound(round: games.jass.logic.data.models.table.history.RoundHistory): string;
     encodeGameRoundItems(round: games.jass.logic.data.models.table.history.RoundHistory): string;
+    encodeGameMetadata(metadata: games.jass.logic.data.models.table.history.GameHistoryMetadata): string;
+    encodeRoomConfig(config: models.RoomConfig): string;
     readonly __doNotUseOrImplementIt: {
         readonly ParserHelper: unique symbol;
     };
 }
+export declare namespace models {
+    class RoomConfig {
+        constructor(players: number, points: number, timeoutTime: number, rulesPreset: string, isPrivate?: Nullable<boolean>, isChatEnabled?: Nullable<boolean>, rules?: Nullable<any>/* Nullable<com.logic.data.models.serializable.rules.RulesDto> */);
+        get players(): number;
+        get points(): number;
+        get timeoutTime(): number;
+        get rulesPreset(): string;
+        get isPrivate(): Nullable<boolean>;
+        get isChatEnabled(): Nullable<boolean>;
+        get rules(): Nullable<any>/* Nullable<com.logic.data.models.serializable.rules.RulesDto> */;
+        copy(players?: number, points?: number, timeoutTime?: number, rulesPreset?: string, isPrivate?: Nullable<boolean>, isChatEnabled?: Nullable<boolean>, rules?: Nullable<any>/* Nullable<com.logic.data.models.serializable.rules.RulesDto> */): models.RoomConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
 export declare namespace games.jass.logic.client.data.models.config {
     abstract class GameType {
         private constructor();
@@ -1375,19 +1664,19 @@ export declare namespace games.jass.logic.client.data.models.config {
             get name(): "SERVER";
             get ordinal(): 1;
         };
-        static get P2P_CLIENT(): games.jass.logic.client.data.models.config.GameType & {
-            get name(): "P2P_CLIENT";
+        static get P2P_PARTICIPANT(): games.jass.logic.client.data.models.config.GameType & {
+            get name(): "P2P_PARTICIPANT";
             get ordinal(): 2;
         };
-        static get P2P_SERVER(): games.jass.logic.client.data.models.config.GameType & {
-            get name(): "P2P_SERVER";
+        static get P2P_HOST(): games.jass.logic.client.data.models.config.GameType & {
+            get name(): "P2P_HOST";
             get ordinal(): 3;
         };
         static get TUTORIAL(): games.jass.logic.client.data.models.config.GameType & {
             get name(): "TUTORIAL";
             get ordinal(): 4;
         };
-        get name(): "SINGLE" | "SERVER" | "P2P_CLIENT" | "P2P_SERVER" | "TUTORIAL";
+        get name(): "SINGLE" | "SERVER" | "P2P_PARTICIPANT" | "P2P_HOST" | "TUTORIAL";
         get ordinal(): 0 | 1 | 2 | 3 | 4;
         static values(): Array<games.jass.logic.client.data.models.config.GameType>;
         static valueOf(value: string): games.jass.logic.client.data.models.config.GameType;
@@ -1415,17 +1704,18 @@ export declare namespace games.jass.logic.client.data.models.config {
 }
 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>>);
+        constructor(gameId: string, createdAt: any/* kotlinx.datetime.Instant */, gameType: games.jass.logic.client.data.models.config.GameType, users: Array<com.logic.data.models.player.GameUserInfo>, config: games.jass.logic.data.models.table.config.ConfigLite, gameWinners: Nullable<Array<string>>, metadata: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>);
         get gameId(): string;
         get createdAt(): any/* kotlinx.datetime.Instant */;
         get gameType(): games.jass.logic.client.data.models.config.GameType;
         get users(): Array<com.logic.data.models.player.GameUserInfo>;
         get config(): games.jass.logic.data.models.table.config.ConfigLite;
         get gameWinners(): Nullable<Array<string>>;
-        toString(): string;
+        get metadata(): Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        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;
+        toString(): string;
+        copy(gameId?: string, createdAt?: any/* kotlinx.datetime.Instant */, gameType?: games.jass.logic.client.data.models.config.GameType, users?: Array<com.logic.data.models.player.GameUserInfo>, config?: games.jass.logic.data.models.table.config.ConfigLite, gameWinners?: Nullable<Array<string>>, metadata?: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>): games.jass.logic.client.data.models.vm.GameHistoryViewModel;
     }
     class RoundEndedHistoryViewModel /* extends games.jass.logic.client.data.models.vm.HistoryViewModel */ {
         constructor(gameId: string, roundNumber: number, items: Array<games.jass.logic.data.models.table.history.RoundHistoryItem>, roundContractState: Nullable<games.jass.logic.data.models.player.state.RoundContractState>, roundCommitted: Nullable<Array<string>>, roundWinners: Nullable<Array<string>>, gameEndedHistory: Nullable<games.jass.logic.client.data.models.vm.GameHistoryViewModel>);
@@ -1490,12 +1780,12 @@ export declare namespace games.jass.logic.client.domain.mechanic.online {
     }
 }
 export declare namespace games.jass.logic.client.utils {
-    interface ShowErrorLoggerOutput extends io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput {
+    interface ShowErrorLoggerOutput extends games.raspberry.logger.output.LoggerOutput {
         skipWarnings: boolean;
         gameClientProvider: Nullable<() => any/* games.jass.logic.client.GameClient */>;
         readonly __doNotUseOrImplementIt: {
             readonly "games.jass.logic.client.utils.ShowErrorLoggerOutput": unique symbol;
-        } & io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput["__doNotUseOrImplementIt"];
+        } & games.raspberry.logger.output.LoggerOutput["__doNotUseOrImplementIt"];
     }
 }
 export declare interface GameClientEngineController {