game_client_logic_deb 1.8.76 → 1.8.104

package/Logic_Debertz-game_client.d.ts

@@ -1,4 +1,24 @@
 type Nullable<T> = T | null | undefined
+export declare namespace kotlin.collections {
+    interface KtList<E> /* extends kotlin.collections.Collection<E> */ {
+        asJsReadonlyArrayView(): ReadonlyArray<E>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "kotlin.collections.KtList": unique symbol;
+        };
+    }
+    interface KtSet<E> /* extends kotlin.collections.Collection<E> */ {
+        asJsReadonlySetView(): ReadonlySet<E>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "kotlin.collections.KtSet": unique symbol;
+        };
+    }
+    interface KtMap<K, V> {
+        asJsReadonlyMapView(): ReadonlyMap<K, V>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "kotlin.collections.KtMap": unique symbol;
+        };
+    }
+}
 export declare namespace io.raspberryapps.cardgame.core {
     const CoreConfig: {
         get version(): string;
@@ -7,9 +27,6 @@ export declare namespace io.raspberryapps.cardgame.core {
 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: string, 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"];
@@ -24,9 +41,6 @@ export declare namespace io.raspberryapps.card_game.core.utils.logger {
 }
 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: string, 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"];
@@ -36,7 +50,7 @@ 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> | undefined, message: string, 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;
         };
@@ -71,6 +85,7 @@ export declare namespace com.logic.data.models {
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
+    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
     class PlayerLostConnectionReason extends com.logic.data.models.TerminationGameReason /* implements com.logic.data.models.FinishPlayerReason */ {
         constructor(playerId: string, tag: Nullable<string>);
         get tag(): Nullable<string>;
@@ -81,6 +96,7 @@ export declare namespace com.logic.data.models {
         static get Companion(): {
         };
     }
+    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
     class PlayerTimeoutReason extends com.logic.data.models.TerminationGameReason /* implements com.logic.data.models.FinishPlayerReason */ {
         constructor(playerId: string, tag: Nullable<string>);
         get tag(): Nullable<string>;
@@ -91,6 +107,7 @@ export declare namespace com.logic.data.models {
         static get Companion(): {
         };
     }
+    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
     class PlayerExitReason extends com.logic.data.models.TerminationGameReason /* implements com.logic.data.models.FinishPlayerReason */ {
         constructor(playerId: string);
         copy(playerId?: string): com.logic.data.models.PlayerExitReason;
@@ -100,6 +117,7 @@ export declare namespace com.logic.data.models {
         static get Companion(): {
         };
     }
+    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
     class GameFinishedReason extends com.logic.data.models.TerminationGameReason {
         constructor(reason: com.logic.data.models.GameFinishedReason.Reason);
         get reason(): com.logic.data.models.GameFinishedReason.Reason;
@@ -129,14 +147,15 @@ export declare namespace com.logic.data.models {
                 get name(): "GAME_NOT_EXISTS";
                 get ordinal(): 3;
             };
-            static values(): Array<com.logic.data.models.GameFinishedReason.Reason>;
-            static valueOf(value: string): com.logic.data.models.GameFinishedReason.Reason;
             get name(): "DEPLOY" | "PLAYER_DELETED" | "NO_ACTIVE_PLAYERS" | "GAME_NOT_EXISTS";
             get ordinal(): 0 | 1 | 2 | 3;
+            static values(): Array<com.logic.data.models.GameFinishedReason.Reason>;
+            static valueOf(value: string): com.logic.data.models.GameFinishedReason.Reason;
             static get Companion(): {
             } & any/* kotlinx.serialization.internal.SerializerFactory */;
         }
     }
+    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
     class GameErrorReason extends com.logic.data.models.TerminationGameReason {
         constructor(reason: string);
         get reason(): string;
@@ -149,9 +168,13 @@ export declare namespace com.logic.data.models {
     }
     const WaitingForConnectionReason: {
         toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
     } & com.logic.data.models.TerminationGameReason & any/* kotlinx.serialization.internal.SerializerFactory */;
     const ProcessingReason: {
         toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
     } & com.logic.data.models.TerminationGameReason & any/* kotlinx.serialization.internal.SerializerFactory */;
 }
 export declare namespace com.logic.data.models.player {
@@ -177,8 +200,8 @@ export declare namespace com.logic.data.models.player {
             readonly "com.logic.data.models.player.PlayerIdContract": unique symbol;
         };
     }
-    function getPlayer<T extends com.logic.data.models.player.PlayerIdContract>(_this_: any/* kotlin.collections.List<T> */, id: string): T;
-    function getPlayerIndex<T extends com.logic.data.models.player.PlayerIdContract>(_this_: any/* kotlin.collections.List<T> */, playerId: string): number;
+    function getPlayer<T extends com.logic.data.models.player.PlayerIdContract>(_this_: kotlin.collections.KtList<T>, id: string): T;
+    function getPlayerIndex<T extends com.logic.data.models.player.PlayerIdContract>(_this_: kotlin.collections.KtList<T>, playerId: string): number;
 }
 export declare namespace com.logic.data.models.player {
     abstract class PlayerConnectionState {
@@ -207,6 +230,8 @@ export declare namespace com.logic.data.models.player {
             get name(): "DELETED";
             get ordinal(): 5;
         };
+        get name(): "LIVE" | "TIMEOUT" | "LOST_CONNECTION" | "LEFT" | "DISCONNECTING" | "DELETED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
         get isLive(): boolean;
         get isTimeOut(): boolean;
         get isLostConnection(): boolean;
@@ -219,26 +244,10 @@ export declare namespace com.logic.data.models.player {
         get isServerDisconnectReason(): boolean;
         static values(): Array<com.logic.data.models.player.PlayerConnectionState>;
         static valueOf(value: string): com.logic.data.models.player.PlayerConnectionState;
-        get name(): "LIVE" | "TIMEOUT" | "LOST_CONNECTION" | "LEFT" | "DISCONNECTING" | "DELETED";
-        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
-export declare namespace com.logic.data.models.player {
-    class PlayerLuckyFactor implements com.logic.data.models.player.PlayerIdContract {
-        constructor(playerId: string, factor: number, wasLiveDuringGame: boolean, liveDurationPercentage: Nullable<number>);
-        get playerId(): string;
-        get factor(): number;
-        get wasLiveDuringGame(): boolean;
-        get liveDurationPercentage(): Nullable<number>;
-        copy(playerId?: string, factor?: number, wasLiveDuringGame?: boolean, liveDurationPercentage?: Nullable<number>): com.logic.data.models.player.PlayerLuckyFactor;
-        toString(): string;
-        hashCode(): number;
-        equals(other: Nullable<any>): boolean;
-        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
-    }
-}
 export declare namespace com.logic.data.models.rules {
     class Rules {
         constructor(needToPutHigherTrump: boolean, distributePoints: boolean, protectBella: boolean, oneTryToProtectBella: boolean, enableFourSevensCombination: boolean, enableTrumpSevenCombination: boolean, enableTrumpSevenCombinationAfterDistribution: boolean, playerWhoChooseSuitGoFirst: boolean, winnerShuffleCards: boolean, playWithoutLiabilities: boolean, trumpCardGoToPlayerWhoShuffleCards: boolean, enableFineIfNoBribes: boolean, fineIfNoBribes: number, enableFineAfterThirdByte: boolean, checkTrumpCombination: boolean, checkOnlyTrumpDebertz: boolean, tenCardsInHand: boolean);
@@ -276,7 +285,6 @@ export declare namespace com.logic.data.models.rules {
 export declare namespace com.logic.data.models.rules {
     abstract class RulesSetType {
         private constructor();
-        get value(): string;
         static get belot(): com.logic.data.models.rules.RulesSetType & {
             get name(): "belot";
             get ordinal(): 0;
@@ -301,12 +309,13 @@ export declare namespace com.logic.data.models.rules {
             get name(): "custom";
             get ordinal(): 5;
         };
+        get name(): "belot" | "klabor" | "debertzCommon" | "debertzKharkiv" | "debertzSaltivka" | "custom";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        get value(): string;
         getRules(): com.logic.data.models.rules.Rules;
         get isCustom(): boolean;
         static values(): Array<com.logic.data.models.rules.RulesSetType>;
         static valueOf(value: string): com.logic.data.models.rules.RulesSetType;
-        get name(): "belot" | "klabor" | "debertzCommon" | "debertzKharkiv" | "debertzSaltivka" | "custom";
-        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
     }
 }
 export declare namespace com.logic.data.models.serializable.rules {
@@ -339,19 +348,16 @@ export declare namespace com.logic.data.models.serializable.rules {
 }
 export declare namespace com.logic.redux.actions {
     interface BufferedAction extends com.logic.redux.store.definitions.Action {
-        readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.redux.actions.BufferedAction": unique symbol;
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
     interface IgnoreBufferForAction extends com.logic.redux.store.definitions.Action {
-        readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.redux.actions.IgnoreBufferForAction": unique symbol;
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
     interface ReleaseBufferTriggerAction extends com.logic.redux.store.definitions.Action {
-        readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.redux.actions.ReleaseBufferTriggerAction": unique symbol;
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
@@ -408,10 +414,10 @@ export declare namespace com.logic.utils.logger.outputs {
             get name(): "WARN";
             get ordinal(): 2;
         };
-        static values(): Array<com.logic.utils.logger.outputs.LogType>;
-        static valueOf(value: string): com.logic.utils.logger.outputs.LogType;
         get name(): "DEBUG" | "ERROR" | "WARN";
         get ordinal(): 0 | 1 | 2;
+        static values(): Array<com.logic.utils.logger.outputs.LogType>;
+        static valueOf(value: string): com.logic.utils.logger.outputs.LogType;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
@@ -419,10 +425,6 @@ 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 {
         observe(types?: Array<com.logic.utils.logger.outputs.LogType>): any/* kotlinx.coroutines.flow.Flow<com.logic.utils.logger.outputs.LoggerOutputDataDto> */;
-        d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
-        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
-        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
-        enabled: boolean;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.utils.logger.outputs.ObservableLoggerOutput": unique symbol;
         } & io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput["__doNotUseOrImplementIt"] & io.raspberryapps.card_game.core.utils.logger.LoggerEnabledTrigger["__doNotUseOrImplementIt"];
@@ -463,6 +465,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 {
@@ -512,14 +518,57 @@ export declare namespace com.debertz.logic.data.models {
             get name(): "FINISHED";
             get ordinal(): 3;
         };
-        static values(): Array<com.debertz.logic.data.models.GameLifecycleState>;
-        static valueOf(value: string): com.debertz.logic.data.models.GameLifecycleState;
         get name(): "CREATED" | "CREATING" | "FINISHING" | "FINISHED";
         get ordinal(): 0 | 1 | 2 | 3;
+        static values(): Array<com.debertz.logic.data.models.GameLifecycleState>;
+        static valueOf(value: string): com.debertz.logic.data.models.GameLifecycleState;
         static get Companion(): {
         } & 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: kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.PlayerAnalytics>);
+        get duration(): any/* kotlin.time.Duration */;
+        get gamesCount(): number;
+        get roundsCountTotal(): number;
+        get playerAnalytics(): kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.PlayerAnalytics>;
+        get allCombinationCounts(): kotlin.collections.KtMap<com.debertz.logic.data.models.table.combinations.CombinationType, number>;
+        copy(duration?: any/* kotlin.time.Duration */, gamesCount?: number, roundsCountTotal?: number, playerAnalytics?: kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.PlayerAnalytics>): com.debertz.logic.data.models.GameSessionAnalytics;
+        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: kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.CombinationRecord>);
+        get playerId(): string;
+        get factor(): number;
+        get wasLiveDuringGame(): boolean;
+        get liveDurationPercentage(): Nullable<number>;
+        get combinationRecords(): kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.CombinationRecord>;
+        get combinationCounts(): kotlin.collections.KtMap<com.debertz.logic.data.models.table.combinations.CombinationType, number>;
+        copy(playerId?: string, factor?: number, wasLiveDuringGame?: boolean, liveDurationPercentage?: Nullable<number>, combinationRecords?: kotlin.collections.KtList<com.debertz.logic.data.models.player.hand.CombinationRecord>): com.debertz.logic.data.models.player.hand.PlayerAnalytics;
+        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();
@@ -535,13 +584,13 @@ export declare namespace com.debertz.logic.data.models.player.state {
             get name(): "CONTROVERSIAL";
             get ordinal(): 2;
         };
+        get name(): "FAILED" | "FULFILLED" | "CONTROVERSIAL";
+        get ordinal(): 0 | 1 | 2;
         get isFailed(): boolean;
         get isFulfilled(): boolean;
         get isControversial(): boolean;
         static values(): Array<com.debertz.logic.data.models.player.state.RoundContractState>;
         static valueOf(value: string): com.debertz.logic.data.models.player.state.RoundContractState;
-        get name(): "FAILED" | "FULFILLED" | "CONTROVERSIAL";
-        get ordinal(): 0 | 1 | 2;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
@@ -564,33 +613,33 @@ export declare namespace com.debertz.logic.data.models.scenes {
 }
 export declare namespace com.debertz.logic.data.models.table {
     class DebertzTable {
-        constructor(id: string, version: string, createdAt: any/* kotlinx.datetime.Instant */, config: com.debertz.logic.data.models.table.config.Config, players: any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */, sceneInfo: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable: any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTable> */, bribes: any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */, cardDeck: Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */, gameInfo: any/* com.debertz.logic.data.models.table.GameInfo */, gameHistory: com.debertz.logic.data.models.table.history.GameHistory);
+        constructor(id: string, version: string, createdAt: any/* kotlinx.datetime.Instant */, config: com.debertz.logic.data.models.table.config.Config, players: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.player.DebertzPlayer */>, sceneInfo: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.table.bribes.CardOnTable */>, bribes: kotlin.collections.KtList<any/* com.debertz.logic.data.models.table.cards.Bribe */>, cardDeck: Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */, gameInfo: any/* com.debertz.logic.data.models.table.GameInfo */, gameHistory: com.debertz.logic.data.models.table.history.GameHistory);
         get id(): string;
         get version(): string;
         get createdAt(): any/* kotlinx.datetime.Instant */;
         get config(): com.debertz.logic.data.models.table.config.Config;
-        get players(): any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */;
+        get players(): kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.player.DebertzPlayer */>;
         get sceneInfo(): any/* com.debertz.logic.data.models.table.scene.SceneInfo */;
-        get cardsOnTable(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTable> */;
-        get bribes(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */;
+        get cardsOnTable(): kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.table.bribes.CardOnTable */>;
+        get bribes(): kotlin.collections.KtList<any/* com.debertz.logic.data.models.table.cards.Bribe */>;
         get cardDeck(): Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */;
         get gameInfo(): any/* com.debertz.logic.data.models.table.GameInfo */;
         get gameHistory(): com.debertz.logic.data.models.table.history.GameHistory;
         get gameId(): string;
         get gameDuration(): any/* kotlin.time.Duration */;
         get gameCreatedAt(): any/* kotlinx.datetime.Instant */;
-        get playersConnections(): any/* kotlin.collections.List<kotlin.Pair<string, com.logic.data.models.player.PlayerConnectionState>> */;
+        get playersConnections(): kotlin.collections.KtList<any/* kotlin.Pair<string, com.logic.data.models.player.PlayerConnectionState> */>;
         get users(): Array<com.logic.data.models.player.GameUserInfo>;
         get isCardDeckExist(): boolean;
         get requireCardDeck(): any/* com.debertz.logic.data.models.table.cards.CardDeck */;
         get currentTrump(): Nullable<any>/* Nullable<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;
+        copy(id?: string, version?: string, createdAt?: any/* kotlinx.datetime.Instant */, config?: com.debertz.logic.data.models.table.config.Config, players?: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.player.DebertzPlayer */>, sceneInfo?: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable?: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.table.bribes.CardOnTable */>, bribes?: kotlin.collections.KtList<any/* com.debertz.logic.data.models.table.cards.Bribe */>, cardDeck?: Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */, gameInfo?: any/* com.debertz.logic.data.models.table.GameInfo */, gameHistory?: com.debertz.logic.data.models.table.history.GameHistory): com.debertz.logic.data.models.table.DebertzTable;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         static get Companion(): {
-            initial(tableId: string, gameId: string, version: string, config: com.debertz.logic.data.models.table.config.Config, players: any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */): com.debertz.logic.data.models.table.DebertzTable;
+            initial(tableId: string, gameId: string, version: string, config: com.debertz.logic.data.models.table.config.Config, players: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* com.debertz.logic.data.models.player.DebertzPlayer */>): com.debertz.logic.data.models.table.DebertzTable;
         };
     }
 }
@@ -619,13 +668,48 @@ export declare namespace com.debertz.logic.data.models.table {
 }
 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;
+        constructor(id: string, type: com.debertz.logic.data.models.table.combinations.CombinationType, cards: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>);
+        copy(id?: string, type?: com.debertz.logic.data.models.table.combinations.CombinationType, cards?: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>): com.debertz.logic.data.models.table.combinations.Combination;
         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;
+        };
+        get name(): "NOT_VERIFIED" | "VERIFYING" | "ACCEPTED" | "NOT_ACCEPTED" | "REJECTED" | "CANCELED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        static values(): Array<com.debertz.logic.data.models.table.combinations.CombinationState>;
+        static valueOf(value: string): com.debertz.logic.data.models.table.combinations.CombinationState;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
 export declare namespace com.debertz.logic.data.models.table.combinations {
     abstract class CombinationType {
         private constructor();
@@ -673,12 +757,12 @@ export declare namespace com.debertz.logic.data.models.table.combinations {
             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 values(): Array<com.debertz.logic.data.models.table.combinations.CombinationType>;
+        static valueOf(value: string): com.debertz.logic.data.models.table.combinations.CombinationType;
         static get Companion(): {
-            getSupportedInRowCardsCombinations(): any/* kotlin.collections.Set<number> */;
+            getSupportedInRowCardsCombinations(): kotlin.collections.KtSet<number>;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
@@ -717,10 +801,10 @@ export declare namespace com.debertz.logic.data.models.table.config {
             get name(): "SUPER_EASY";
             get ordinal(): 4;
         };
-        static values(): Array<com.debertz.logic.data.models.table.config.BotIntelligenceLevel>;
-        static valueOf(value: string): com.debertz.logic.data.models.table.config.BotIntelligenceLevel;
         get name(): "SUPER_HARD" | "HARD" | "MEDIUM" | "EASY" | "SUPER_EASY";
         get ordinal(): 0 | 1 | 2 | 3 | 4;
+        static values(): Array<com.debertz.logic.data.models.table.config.BotIntelligenceLevel>;
+        static valueOf(value: string): com.debertz.logic.data.models.table.config.BotIntelligenceLevel;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
@@ -736,6 +820,7 @@ export declare namespace com.debertz.logic.data.models.table.config {
         get pointsMode(): com.debertz.logic.data.models.table.config.PointsMode;
         get timeoutTimeMillis(): number;
         get isPrivate(): boolean;
+        get playerHandCardsSize(): number;
         copy(rules?: com.logic.data.models.rules.Rules, rulesSetType?: com.logic.data.models.rules.RulesSetType, options?: com.debertz.logic.data.models.table.config.Options, playersMode?: com.debertz.logic.data.models.table.config.PlayersMode, pointsMode?: com.debertz.logic.data.models.table.config.PointsMode, timeoutTimeMillis?: number, isPrivate?: boolean): com.debertz.logic.data.models.table.config.Config;
         toString(): string;
         hashCode(): number;
@@ -775,7 +860,6 @@ export declare namespace com.debertz.logic.data.models.table.config {
 export declare namespace com.debertz.logic.data.models.table.config {
     abstract class PlayersMode {
         private constructor();
-        get value(): number;
         static get TWO_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
             get name(): "TWO_PLAYERS";
             get ordinal(): 0;
@@ -792,12 +876,13 @@ export declare namespace com.debertz.logic.data.models.table.config {
             get name(): "FOUR_PLAYERS_BY_TEAM";
             get ordinal(): 3;
         };
+        get name(): "TWO_PLAYERS" | "THREE_PLAYERS" | "FOUR_PLAYERS" | "FOUR_PLAYERS_BY_TEAM";
+        get ordinal(): 0 | 1 | 2 | 3;
+        get value(): number;
         get isTeamGame(): boolean;
         get count(): number;
         static values(): Array<com.debertz.logic.data.models.table.config.PlayersMode>;
         static valueOf(value: string): com.debertz.logic.data.models.table.config.PlayersMode;
-        get name(): "TWO_PLAYERS" | "THREE_PLAYERS" | "FOUR_PLAYERS" | "FOUR_PLAYERS_BY_TEAM";
-        get ordinal(): 0 | 1 | 2 | 3;
         static get Companion(): {
             create(points: number): com.debertz.logic.data.models.table.config.PlayersMode;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
@@ -806,7 +891,6 @@ export declare namespace com.debertz.logic.data.models.table.config {
 export declare namespace com.debertz.logic.data.models.table.config {
     abstract class PointsMode {
         private constructor();
-        get value(): number;
         static get SMALL(): com.debertz.logic.data.models.table.config.PointsMode & {
             get name(): "SMALL";
             get ordinal(): 0;
@@ -823,10 +907,11 @@ export declare namespace com.debertz.logic.data.models.table.config {
             get name(): "TEST";
             get ordinal(): 3;
         };
-        static values(): Array<com.debertz.logic.data.models.table.config.PointsMode>;
-        static valueOf(value: string): com.debertz.logic.data.models.table.config.PointsMode;
         get name(): "SMALL" | "MEDIUM" | "BIG" | "TEST";
         get ordinal(): 0 | 1 | 2 | 3;
+        get value(): number;
+        static values(): Array<com.debertz.logic.data.models.table.config.PointsMode>;
+        static valueOf(value: string): com.debertz.logic.data.models.table.config.PointsMode;
         static get Companion(): {
             create(points: number): com.debertz.logic.data.models.table.config.PointsMode;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
@@ -841,6 +926,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;
@@ -895,16 +981,18 @@ export declare namespace com.debertz.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;
         shouldEqualiseHand(): boolean;
         static values(): Array<com.debertz.logic.domain.interactors.dealer.DealerStrategy>;
         static valueOf(value: string): com.debertz.logic.domain.interactors.dealer.DealerStrategy;
-        get name(): "FAKE" | "BASED_ON_PREVIOUS" | "EQUAL_HAND_BY_POINTS" | "EQUAL_HAND_BY_VALUE" | "RANDOM";
-        get ordinal(): 0 | 1 | 2 | 3 | 4;
     }
 }
 export declare namespace com.debertz.logic.redux.actions {
     const ClearAction: {
         toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
         get actionTag(): string;
         notValidateWhenFinishing(): boolean;
         notValidateWhenFinished(): boolean;
@@ -934,6 +1022,7 @@ export declare namespace com.debertz.logic.redux.actions.client.to {
         toString(): string;
         copy(id?: string, includePlayers?: Array<string>, excludePlayers?: Array<string>, deliveryType?: com.debertz.logic.redux.actions.client.to.ActionDeliveryType): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
         static get Companion(): {
+            userFromTable(table: com.debertz.logic.data.models.table.DebertzTable, sendToPlayerId: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
             user(tableId: string, sendToPlayerId: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
         };
     }
@@ -951,10 +1040,10 @@ export declare namespace com.debertz.logic.redux.actions.client.to {
             get name(): "USER";
             get ordinal(): 2;
         };
-        static values(): Array<com.debertz.logic.redux.actions.client.to.ActionDeliveryType>;
-        static valueOf(value: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryType;
         get name(): "ROOM_ALL" | "ROOM_EXCEPT_USER" | "USER";
         get ordinal(): 0 | 1 | 2;
+        static values(): Array<com.debertz.logic.redux.actions.client.to.ActionDeliveryType>;
+        static valueOf(value: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryType;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
@@ -989,7 +1078,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;
@@ -999,14 +1088,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 {
@@ -1030,22 +1120,21 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
     interface FirstMechanicAction extends com.logic.redux.store.definitions.Action, com.logic.redux.actions.IgnoreBufferForAction {
         readonly id: string;
         readonly version: string;
-        readonly users: any/* kotlin.collections.List<com.logic.data.models.player.GameUserInfo> */;
+        readonly users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>;
         readonly config: com.debertz.logic.data.models.table.config.Config;
         readonly gameCreatorPlayerId: string;
-        readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.debertz.logic.redux.actions.mechanic.FirstMechanicAction": unique symbol;
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.IgnoreBufferForAction["__doNotUseOrImplementIt"];
     }
     class StartGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.FirstMechanicAction {
-        constructor(config: com.debertz.logic.data.models.table.config.Config, id: string, version: string, gameCreatorPlayerId: string, users: any/* kotlin.collections.List<com.logic.data.models.player.GameUserInfo> */);
+        constructor(config: com.debertz.logic.data.models.table.config.Config, id: string, version: string, gameCreatorPlayerId: string, users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>);
         get config(): com.debertz.logic.data.models.table.config.Config;
         get id(): string;
         get version(): string;
         get gameCreatorPlayerId(): string;
-        get users(): any/* kotlin.collections.List<com.logic.data.models.player.GameUserInfo> */;
-        copy(config?: com.debertz.logic.data.models.table.config.Config, id?: string, version?: string, gameCreatorPlayerId?: string, users?: any/* kotlin.collections.List<com.logic.data.models.player.GameUserInfo> */): com.debertz.logic.redux.actions.mechanic.StartGameMechanicAction;
+        get users(): kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>;
+        copy(config?: com.debertz.logic.data.models.table.config.Config, id?: string, version?: string, gameCreatorPlayerId?: string, users?: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>): com.debertz.logic.redux.actions.mechanic.StartGameMechanicAction;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -1062,16 +1151,21 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
     }
+    /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
     class FinishingGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.TerminatedAction {
-        constructor(reason: com.logic.data.models.TerminationGameReason, 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);
@@ -1088,7 +1182,6 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         readonly sceneId: string;
         readonly actId: Nullable<string>;
         readonly actData: Nullable<com.debertz.logic.data.models.scenes.ActData>;
-        readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction": unique symbol;
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
@@ -1101,8 +1194,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;
@@ -1110,7 +1203,6 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
     }
     interface TerminatedAction extends com.logic.redux.store.definitions.Action {
         readonly reason: com.logic.data.models.TerminationGameReason;
-        readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.debertz.logic.redux.actions.mechanic.TerminatedAction": unique symbol;
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
@@ -1125,8 +1217,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;
@@ -1172,23 +1264,24 @@ export declare namespace com.debertz.logic.client.data.models.config {
             get name(): "TUTORIAL";
             get ordinal(): 4;
         };
-        static values(): Array<com.debertz.logic.client.data.models.config.GameType>;
-        static valueOf(value: string): com.debertz.logic.client.data.models.config.GameType;
         get name(): "SINGLE" | "SERVER" | "P2P_CLIENT" | "P2P_SERVER" | "TUTORIAL";
         get ordinal(): 0 | 1 | 2 | 3 | 4;
+        static values(): Array<com.debertz.logic.client.data.models.config.GameType>;
+        static valueOf(value: string): com.debertz.logic.client.data.models.config.GameType;
         static get Companion(): {
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
 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;
@@ -1233,14 +1326,14 @@ export declare namespace com.debertz.logic.client.domain.mechanic {
         getConfig(): com.debertz.logic.data.models.table.config.Config;
         getClientConfig(): any/* com.debertz.logic.client.data.models.config.ClientConfig */;
         observeConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.data.models.table.config.Config> */;
-        observeUsers(): any/* kotlinx.coroutines.flow.Flow<kotlin.collections.List<com.logic.data.models.player.GameUserInfo>> */;
+        observeUsers(): any/* kotlinx.coroutines.flow.Flow<kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>> */;
         observeClientConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.ClientConfig> */;
         observePlayersHandsMetadata(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.PlayersHandsMetadataViewModel> */;
         observeGameLifecycle(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.GameLifecycleViewModel> */;
         observeRestartGameExpectant(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.expectants.RestartGameExpectant>> */;
         observeScene(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.SceneViewModel> */;
         observeSceneId(): any/* kotlinx.coroutines.flow.Flow<string> */;
-        observeError(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.redux.state.ErrorState>> */;
+        observeError(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.data.models.table.error.ErrorState>> */;
         observeInfoMessage(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.data.models.messages.Message>> */;
         observeGameType(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.GameType> */;
         observeChatOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
@@ -1256,12 +1349,8 @@ export declare namespace com.debertz.logic.client.domain.mechanic {
         observeShowTutorial(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
         tutorialPassed(skipped: boolean): void;
         playerExit(): void;
-        error(error: Nullable<com.debertz.logic.client.redux.state.ErrorState>): void;
+        error(error: Nullable<any>/* Nullable<com.debertz.logic.data.models.table.error.ErrorState> */): void;
         observeGameHistoryEvents(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.vm.HistoryViewModel> */;
-        readonly id: string;
-        readonly table: com.debertz.logic.data.models.table.DebertzTable;
-        readonly isTableExists: boolean;
-        readonly gameLifecycleState: com.debertz.logic.data.models.GameLifecycleState;
         readonly __doNotUseOrImplementIt: {
             readonly "com.debertz.logic.client.domain.mechanic.GameMechanic": unique symbol;
         } & com.debertz.logic.GameStoreContract["__doNotUseOrImplementIt"];
@@ -1272,64 +1361,15 @@ export declare namespace com.debertz.logic.client.domain.mechanic.online {
         readonly currentPlayerId: string;
         observeFromClientAction(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.redux.actions.client.from.FromClientAction> */;
         mechanicAction(action: com.debertz.logic.redux.actions.mechanic.MechanicAction): void;
-        onCreate(): void;
-        onDestroy(): void;
-        getConfig(): com.debertz.logic.data.models.table.config.Config;
-        getClientConfig(): any/* com.debertz.logic.client.data.models.config.ClientConfig */;
-        observeConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.data.models.table.config.Config> */;
-        observeUsers(): any/* kotlinx.coroutines.flow.Flow<kotlin.collections.List<com.logic.data.models.player.GameUserInfo>> */;
-        observeClientConfig(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.ClientConfig> */;
-        observePlayersHandsMetadata(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.PlayersHandsMetadataViewModel> */;
-        observeGameLifecycle(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.GameLifecycleViewModel> */;
-        observeRestartGameExpectant(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.expectants.RestartGameExpectant>> */;
-        observeScene(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.SceneViewModel> */;
-        observeSceneId(): any/* kotlinx.coroutines.flow.Flow<string> */;
-        observeError(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.redux.state.ErrorState>> */;
-        observeInfoMessage(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.data.models.messages.Message>> */;
-        observeGameType(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.config.GameType> */;
-        observeChatOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
-        observeLastBribe(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.LastBribeViewModel>> */;
-        observeGameInfo(): any/* kotlinx.coroutines.flow.Flow<Nullable<com.debertz.logic.client.data.models.GameInfoViewModel>> */;
-        observeSettingsOpened(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
-        switchLastBribe(open: boolean): void;
-        switchGameInfo(open: boolean): void;
-        switchSettings(open: boolean): void;
-        switchChat(open: boolean): void;
-        foreground(foreground: boolean): void;
-        updateConfig(updateConfig: any/* com.debertz.logic.client.data.models.config.UpdateConfigModel */): void;
-        observeShowTutorial(): any/* kotlinx.coroutines.flow.Flow<boolean> */;
-        tutorialPassed(skipped: boolean): void;
-        playerExit(): void;
-        error(error: Nullable<com.debertz.logic.client.redux.state.ErrorState>): void;
-        observeGameHistoryEvents(): any/* kotlinx.coroutines.flow.Flow<com.debertz.logic.client.data.models.vm.HistoryViewModel> */;
-        readonly id: string;
-        readonly table: com.debertz.logic.data.models.table.DebertzTable;
-        readonly isTableExists: boolean;
-        readonly gameLifecycleState: com.debertz.logic.data.models.GameLifecycleState;
         readonly __doNotUseOrImplementIt: {
             readonly "com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic": unique symbol;
         } & com.debertz.logic.client.domain.mechanic.GameMechanic["__doNotUseOrImplementIt"];
     }
 }
-export declare namespace com.debertz.logic.client.redux.state {
-    class ErrorState {
-        constructor(message: Nullable<string> | undefined, userInfo: Nullable<com.logic.data.models.player.GameUserInfo> | undefined, reason: com.logic.data.models.TerminationGameReason);
-        get message(): Nullable<string>;
-        get userInfo(): Nullable<com.logic.data.models.player.GameUserInfo>;
-        get reason(): com.logic.data.models.TerminationGameReason;
-        copy(message?: Nullable<string>, userInfo?: Nullable<com.logic.data.models.player.GameUserInfo>, reason?: com.logic.data.models.TerminationGameReason): com.debertz.logic.client.redux.state.ErrorState;
-        toString(): string;
-        hashCode(): number;
-        equals(other: Nullable<any>): boolean;
-    }
-}
 export declare namespace com.debertz.logic.client.utils {
     interface ShowErrorLoggerOutput extends io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput {
         skipWarnings: boolean;
         gameClientProvider: Nullable<() => any/* com.debertz.logic.client.GameClient */>;
-        d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
-        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
-        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
         readonly __doNotUseOrImplementIt: {
             readonly "com.debertz.logic.client.utils.ShowErrorLoggerOutput": unique symbol;
         } & io.raspberryapps.card_game.core.utils.logger.output.LoggerOutput["__doNotUseOrImplementIt"];