game_client_logic_deb 1.8.72 → 1.8.96

package/Logic_Debertz-game_client.d.ts

@@ -1,4 +1,47 @@
 type Nullable<T> = T | null | undefined
+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 {
+        enabled: boolean;
+        d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
+        w(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.raspberryapps.card_game.core.utils.logger.LoggerEnabledTrigger": unique symbol;
+        } & io.raspberryapps.card_game.core.utils.logger.RaspberryLogger["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace io.raspberryapps.card_game.core.utils.logger {
+    interface LoggerPayload {
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.raspberryapps.card_game.core.utils.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 {
+        d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
+        w(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.raspberryapps.card_game.core.utils.logger.RaspberryLogger": unique symbol;
+        } & io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace io.raspberryapps.card_game.core.utils.logger.output {
+    interface LoggerOutput {
+        d(tag: Nullable<string> | undefined, message: string, payload?: Nullable<any>): void;
+        e(tag?: Nullable<string>, message?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
+        w(tag?: Nullable<string>, message?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput": unique symbol;
+        };
+    }
+}
 export declare namespace com.logic {
     const GameEngineConfig: {
         get version(): string;
@@ -182,20 +225,6 @@ export declare namespace com.logic.data.models.player {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
-export declare namespace com.logic.data.models.player {
-    class PlayerLuckyFactor implements com.logic.data.models.player.PlayerIdContract {
-        constructor(playerId: string, factor: number, wasLiveDuringGame: boolean, liveDurationPercentage: Nullable<number>);
-        get playerId(): string;
-        get factor(): number;
-        get wasLiveDuringGame(): boolean;
-        get liveDurationPercentage(): Nullable<number>;
-        copy(playerId?: string, factor?: number, wasLiveDuringGame?: boolean, liveDurationPercentage?: Nullable<number>): com.logic.data.models.player.PlayerLuckyFactor;
-        toString(): string;
-        hashCode(): number;
-        equals(other: Nullable<any>): boolean;
-        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
-    }
-}
 export declare namespace com.logic.data.models.rules {
     class Rules {
         constructor(needToPutHigherTrump: boolean, distributePoints: boolean, protectBella: boolean, oneTryToProtectBella: boolean, enableFourSevensCombination: boolean, enableTrumpSevenCombination: boolean, enableTrumpSevenCombinationAfterDistribution: boolean, playerWhoChooseSuitGoFirst: boolean, winnerShuffleCards: boolean, playWithoutLiabilities: boolean, trumpCardGoToPlayerWhoShuffleCards: boolean, enableFineIfNoBribes: boolean, fineIfNoBribes: number, enableFineAfterThirdByte: boolean, checkTrumpCombination: boolean, checkOnlyTrumpDebertz: boolean, tenCardsInHand: boolean);
@@ -350,23 +379,6 @@ export declare namespace com.logic.redux.store.definitions {
         };
     }
 }
-export declare namespace com.logic.utils.logger.game {
-    interface GameLogger extends com.logic.utils.logger.outputs.LoggerOutput {
-        d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
-        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
-        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
-        readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.utils.logger.game.GameLogger": unique symbol;
-        } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"];
-    }
-}
-export declare namespace com.logic.utils.logger.game {
-    interface LoggerPayload {
-        readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.utils.logger.game.LoggerPayload": unique symbol;
-        };
-    }
-}
 export declare namespace com.logic.utils.logger.outputs {
     abstract class LogType {
         private constructor();
@@ -391,36 +403,15 @@ export declare namespace com.logic.utils.logger.outputs {
     }
 }
 export declare namespace com.logic.utils.logger.outputs {
-    interface LoggerEnabledTrigger extends com.logic.utils.logger.game.GameLogger {
-        enabled: boolean;
-        d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
-        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
-        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
-        readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.utils.logger.outputs.LoggerEnabledTrigger": unique symbol;
-        } & com.logic.utils.logger.game.GameLogger["__doNotUseOrImplementIt"];
-    }
-}
-export declare namespace com.logic.utils.logger.outputs {
-    interface LoggerOutput {
-        d(tag: Nullable<string> | undefined, message: string, payload?: Nullable<any>): void;
-        e(tag?: Nullable<string>, message?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
-        w(tag: Nullable<string> | undefined, message: string, payload?: Nullable<any>): void;
-        readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.utils.logger.outputs.LoggerOutput": unique symbol;
-        };
-    }
-}
-export declare namespace com.logic.utils.logger.outputs {
-    interface ObservableLoggerOutput extends com.logic.utils.logger.outputs.LoggerOutput, com.logic.utils.logger.outputs.LoggerEnabledTrigger {
+    interface ObservableLoggerOutput extends io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput, io.raspberryapps.card_game.core.utils.logger.LoggerEnabledTrigger {
         observe(types?: Array<com.logic.utils.logger.outputs.LogType>): any/* kotlinx.coroutines.flow.Flow<com.logic.utils.logger.outputs.LoggerOutputDataDto> */;
         d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
         e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
-        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        w(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
         enabled: boolean;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.utils.logger.outputs.ObservableLoggerOutput": unique symbol;
-        } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"] & com.logic.utils.logger.outputs.LoggerEnabledTrigger["__doNotUseOrImplementIt"];
+        } & io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput["__doNotUseOrImplementIt"] & io.raspberryapps.card_game.core.utils.logger.LoggerEnabledTrigger["__doNotUseOrImplementIt"];
     }
     class LoggerOutputDataDto {
         constructor(type: com.logic.utils.logger.outputs.LogType, tag: Nullable<string>, message: Nullable<string>, stackTrace: Nullable<string>);
@@ -458,6 +449,10 @@ export declare namespace com.debertz.logic.data.models {
         hashCode(): number;
         copy(dealerStrategy?: com.debertz.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean, cards?: Nullable<Array<number>>): com.debertz.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;
+        };
     }
 }
 export declare namespace com.debertz.logic.data.models {
@@ -515,6 +510,49 @@ export declare namespace com.debertz.logic.data.models {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
+export declare namespace com.debertz.logic.data.models {
+    class GameSessionAnalytics {
+        constructor(duration: any/* kotlin.time.Duration */, gamesCount: number, roundsCountTotal: number, playerAnalytics: any/* kotlin.collections.List<com.debertz.logic.data.models.player.hand.PlayerAnalytics> */);
+        get duration(): any/* kotlin.time.Duration */;
+        get gamesCount(): number;
+        get roundsCountTotal(): number;
+        get playerAnalytics(): any/* kotlin.collections.List<com.debertz.logic.data.models.player.hand.PlayerAnalytics> */;
+        get allCombinationCounts(): any/* kotlin.collections.Map<com.debertz.logic.data.models.table.combinations.CombinationType, number> */;
+        copy(duration?: any/* kotlin.time.Duration */, gamesCount?: number, roundsCountTotal?: number, playerAnalytics?: any/* kotlin.collections.List<com.debertz.logic.data.models.player.hand.PlayerAnalytics> */): com.debertz.logic.data.models.GameSessionAnalytics;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace com.debertz.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);
+        get id(): string;
+        get type(): com.debertz.logic.data.models.table.combinations.CombinationType;
+        get state(): com.debertz.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;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace com.debertz.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: any/* kotlin.collections.List<com.debertz.logic.data.models.player.hand.CombinationRecord> */);
+        get playerId(): string;
+        get factor(): number;
+        get wasLiveDuringGame(): boolean;
+        get liveDurationPercentage(): Nullable<number>;
+        get combinationRecords(): any/* kotlin.collections.List<com.debertz.logic.data.models.player.hand.CombinationRecord> */;
+        get combinationCounts(): any/* kotlin.collections.Map<com.debertz.logic.data.models.table.combinations.CombinationType, number> */;
+        copy(playerId?: string, factor?: number, wasLiveDuringGame?: boolean, liveDurationPercentage?: Nullable<number>, combinationRecords?: any/* kotlin.collections.List<com.debertz.logic.data.models.player.hand.CombinationRecord> */): com.debertz.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 {
     abstract class RoundContractState {
         private constructor();
@@ -578,7 +616,7 @@ export declare namespace com.debertz.logic.data.models.table {
         get users(): Array<com.logic.data.models.player.GameUserInfo>;
         get isCardDeckExist(): boolean;
         get requireCardDeck(): any/* com.debertz.logic.data.models.table.cards.CardDeck */;
-        get currentTrump(): Nullable<any>/* Nullable<com.logic.data.models.table.cards.Suit> */;
+        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?: any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */, sceneInfo?: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable?: any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTable> */, bribes?: any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */, cardDeck?: Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */, gameInfo?: any/* com.debertz.logic.data.models.table.GameInfo */, gameHistory?: com.debertz.logic.data.models.table.history.GameHistory): com.debertz.logic.data.models.table.DebertzTable;
@@ -590,7 +628,7 @@ export declare namespace com.debertz.logic.data.models.table {
     }
 }
 export declare namespace com.debertz.logic.data.models.table {
-    class TableLoggerPayload implements com.logic.utils.logger.game.LoggerPayload {
+    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>);
         get id(): string;
         get gameId(): string;
@@ -599,9 +637,9 @@ export declare namespace com.debertz.logic.data.models.table {
         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;
-        readonly __doNotUseOrImplementIt: com.logic.utils.logger.game.LoggerPayload["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: io.raspberryapps.card_game.core.utils.logger.LoggerPayload["__doNotUseOrImplementIt"];
     }
-    class PlayerLoggerPayload implements com.logic.utils.logger.game.LoggerPayload {
+    class PlayerLoggerPayload implements io.raspberryapps.card_game.core.utils.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>;
@@ -609,7 +647,119 @@ export declare namespace com.debertz.logic.data.models.table {
         copy(playerId?: string, connectionState?: Nullable<com.logic.data.models.player.PlayerConnectionState>): com.debertz.logic.data.models.table.PlayerLoggerPayload;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        readonly __doNotUseOrImplementIt: com.logic.utils.logger.game.LoggerPayload["__doNotUseOrImplementIt"];
+        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<any>/* Nullable<kotlin.collections.List<io.raspberryapps.card_game.core.data.models.cards.GameCard>> */);
+        copy(id?: string, type?: com.debertz.logic.data.models.table.combinations.CombinationType, cards?: Nullable<any>/* Nullable<kotlin.collections.List<io.raspberryapps.card_game.core.data.models.cards.GameCard>> */): com.debertz.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 {
+    abstract class CombinationState {
+        private constructor();
+        static get NOT_VERIFIED(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+            get name(): "NOT_VERIFIED";
+            get ordinal(): 0;
+        };
+        static get VERIFYING(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+            get name(): "VERIFYING";
+            get ordinal(): 1;
+        };
+        static get ACCEPTED(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+            get name(): "ACCEPTED";
+            get ordinal(): 2;
+        };
+        static get NOT_ACCEPTED(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+            get name(): "NOT_ACCEPTED";
+            get ordinal(): 3;
+        };
+        static get REJECTED(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+            get name(): "REJECTED";
+            get ordinal(): 4;
+        };
+        static get CANCELED(): com.debertz.logic.data.models.table.combinations.CombinationState & {
+            get name(): "CANCELED";
+            get ordinal(): 5;
+        };
+        static values(): Array<com.debertz.logic.data.models.table.combinations.CombinationState>;
+        static valueOf(value: string): com.debertz.logic.data.models.table.combinations.CombinationState;
+        get name(): "NOT_VERIFIED" | "VERIFYING" | "ACCEPTED" | "NOT_ACCEPTED" | "REJECTED" | "CANCELED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace com.debertz.logic.data.models.table.combinations {
+    abstract class CombinationType {
+        private constructor();
+        static get BELA(): com.debertz.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 & {
+            get name(): "THREE_IN_ROW";
+            get ordinal(): 1;
+        };
+        static get FOUR_IN_ROW(): com.debertz.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";
+            get ordinal(): 3;
+        };
+        static get SEVEN_TRUMP(): com.debertz.logic.data.models.table.combinations.CombinationType & {
+            get name(): "SEVEN_TRUMP";
+            get ordinal(): 4;
+        };
+        static get FOUR_SEVENS(): com.debertz.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_SEVENS";
+            get ordinal(): 5;
+        };
+        static get FINE_NO_BRIBES(): com.debertz.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FINE_NO_BRIBES";
+            get ordinal(): 6;
+        };
+        static get FINE_THIRD_FAILED_CONTRACT(): com.debertz.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FINE_THIRD_FAILED_CONTRACT";
+            get ordinal(): 7;
+        };
+        static get BONUS_LAST_BRIBE(): com.debertz.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BONUS_LAST_BRIBE";
+            get ordinal(): 8;
+        };
+        static get BONUS_FAILED_CONTRACT(): com.debertz.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BONUS_FAILED_CONTRACT";
+            get ordinal(): 9;
+        };
+        static get BONUS_CONTROVERSIAL_CONTRACT(): com.debertz.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BONUS_CONTROVERSIAL_CONTRACT";
+            get ordinal(): 10;
+        };
+        static values(): Array<com.debertz.logic.data.models.table.combinations.CombinationType>;
+        static valueOf(value: string): com.debertz.logic.data.models.table.combinations.CombinationType;
+        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 get Companion(): {
+            getSupportedInRowCardsCombinations(): any/* kotlin.collections.Set<number> */;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace com.debertz.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>);
+        get playerId(): string;
+        get combinations(): Array<com.debertz.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;
+        toString(): string;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace com.debertz.logic.data.models.table.config {
@@ -759,6 +909,7 @@ export declare namespace com.debertz.logic.data.models.table.history {
         get date(): string;
         get lastRoundHistory(): com.debertz.logic.data.models.table.history.RoundHistory;
         get isFirstRound(): boolean;
+        get roundsCount(): number;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
         toString(): string;
@@ -907,7 +1058,7 @@ export declare namespace com.debertz.logic.redux.actions.game {
         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, luckyFactors: Nullable<Array<com.logic.data.models.player.PlayerLuckyFactor>> | undefined, gameHistory: com.debertz.logic.data.models.table.history.GameHistory);
+        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);
         get id(): string;
         get gameId(): string;
         get roundNumber(): number;
@@ -917,13 +1068,15 @@ export declare namespace com.debertz.logic.redux.actions.game {
         get roundWinners(): Array<string>;
         get gameLosers(): Nullable<Array<string>>;
         get gameWinners(): Nullable<Array<string>>;
-        get luckyFactors(): Nullable<Array<com.logic.data.models.player.PlayerLuckyFactor>>;
+        get playersGameAnalytics(): Nullable<Array<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 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>>, luckyFactors?: Nullable<Array<com.logic.data.models.player.PlayerLuckyFactor>>, gameHistory?: com.debertz.logic.data.models.table.history.GameHistory): com.debertz.logic.redux.actions.game.RoundEndedAction;
+        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;
         get actionTag(): string;
     }
     class PartyRestartedAction implements com.logic.redux.store.definitions.Action {
@@ -980,15 +1133,19 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         get actionTag(): string;
     }
     class FinishingGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.TerminatedAction {
-        constructor(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean);
+        constructor(reason: com.logic.data.models.TerminationGameReason, sessionAnalytics: Nullable<com.debertz.logic.data.models.GameSessionAnalytics> | undefined, isGameFinished: boolean);
         get reason(): com.logic.data.models.TerminationGameReason;
+        get sessionAnalytics(): Nullable<com.debertz.logic.data.models.GameSessionAnalytics>;
         get isGameFinished(): boolean;
-        copy(reason?: com.logic.data.models.TerminationGameReason, isGameFinished?: boolean): com.debertz.logic.redux.actions.mechanic.FinishingGameMechanicAction;
         toString(): string;
+        copy(reason?: com.logic.data.models.TerminationGameReason, sessionAnalytics?: Nullable<com.debertz.logic.data.models.GameSessionAnalytics>, isGameFinished?: boolean): com.debertz.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"];
+        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;
+        };
     }
     class FinishGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.debertz.logic.redux.actions.mechanic.TerminatedAction {
         constructor(reason: com.logic.data.models.TerminationGameReason);
@@ -1018,8 +1175,8 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         get actData(): Nullable<com.debertz.logic.data.models.scenes.ActData>;
         notValidateWhenFinished(): boolean;
         notValidateWhenFinishing(): boolean;
-        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;
         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;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
@@ -1042,8 +1199,8 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         get isShouldBeDisconnectedFromSockets(): boolean;
         get isDeleted(): boolean;
         get shouldNotifyPlayers(): boolean;
-        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;
         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;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
@@ -1099,13 +1256,14 @@ export declare namespace com.debertz.logic.client.data.models.config {
 }
 export declare namespace com.debertz.logic.client.data.models.config {
     class GameClientConfig {
-        constructor(validateSceneActiveState?: boolean, validateCardOnMove?: boolean, validateExpectantActions?: boolean, isAutoStepCurrentPlayer?: boolean, areOpponentsCardsOpened?: boolean);
+        constructor(validateSceneActiveState?: boolean, validateCardOnMove?: boolean, validateExpectantActions?: boolean, isAutoStepCurrentPlayer?: boolean, areOpponentsCardsOpened?: boolean, sessionAnalytics?: boolean);
         get validateSceneActiveState(): boolean;
         get validateCardOnMove(): boolean;
         get validateExpectantActions(): boolean;
         get isAutoStepCurrentPlayer(): boolean;
         get areOpponentsCardsOpened(): boolean;
-        copy(validateSceneActiveState?: boolean, validateCardOnMove?: boolean, validateExpectantActions?: boolean, isAutoStepCurrentPlayer?: boolean, areOpponentsCardsOpened?: boolean): com.debertz.logic.client.data.models.config.GameClientConfig;
+        get sessionAnalytics(): boolean;
+        copy(validateSceneActiveState?: boolean, validateCardOnMove?: boolean, validateExpectantActions?: boolean, isAutoStepCurrentPlayer?: boolean, areOpponentsCardsOpened?: boolean, sessionAnalytics?: boolean): com.debertz.logic.client.data.models.config.GameClientConfig;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -1241,15 +1399,15 @@ export declare namespace com.debertz.logic.client.redux.state {
     }
 }
 export declare namespace com.debertz.logic.client.utils {
-    interface ShowErrorLoggerOutput extends com.logic.utils.logger.outputs.LoggerOutput {
+    interface ShowErrorLoggerOutput extends io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput {
         skipWarnings: boolean;
         gameClientProvider: Nullable<() => any/* com.debertz.logic.client.GameClient */>;
         d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
         e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
-        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        w(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
         readonly __doNotUseOrImplementIt: {
             readonly "com.debertz.logic.client.utils.ShowErrorLoggerOutput": unique symbol;
-        } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"];
+        } & io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput["__doNotUseOrImplementIt"];
     }
 }
 export declare interface GameClientEngineController {
@@ -1262,4 +1420,4 @@ export declare interface GameClientEngineController {
     };
 }
 export declare function createGameClientController(loggerCallback: (p0: string, p1: Nullable<string>, p2: string, p3: Nullable<Error>, p4: Nullable<any>) => void): GameClientEngineController;
-export as namespace com_gamewithcats_game_engine_game_client;
+export as namespace io_raspberryapps_game_engine_game_client;