client_plugin_logic_deb 1.5.0 → 1.5.17

package/Logic_Debertz-client_plugin.d.ts

@@ -7,21 +7,20 @@ export declare namespace com.logic {
 export declare namespace com.logic.data.models {
     abstract class TerminationGameReason {
         protected constructor();
-        static TerminationGameReason_init_$Create$(seen1: number, serializationConstructorMarker: Nullable<any>/* Nullable<kotlinx.serialization.internal.SerializationConstructorMarker> */): com.logic.data.models.TerminationGameReason;
         static get Companion(): {
-            serializer(): any/* kotlinx.serialization.KSerializer<com.logic.data.models.TerminationGameReason> */;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
 export declare namespace com.logic.data.models.player {
     class GameUserInfo implements com.logic.data.models.player.PlayerIdContract {
-        constructor(playerId: string, name: string, avatarUrl?: Nullable<string>, isBot?: boolean, payload?: Nullable<any>);
+        constructor(playerId: string, name: string, avatarUrl?: Nullable<string>, isBot?: boolean, initialLuckyFactor?: Nullable<number>, payload?: Nullable<any>);
         get playerId(): string;
         get name(): string;
         get avatarUrl(): Nullable<string>;
         get isBot(): boolean;
+        get initialLuckyFactor(): Nullable<number>;
         get payload(): Nullable<any>;
-        copy(playerId?: string, name?: string, avatarUrl?: Nullable<string>, isBot?: boolean, payload?: Nullable<any>): com.logic.data.models.player.GameUserInfo;
+        copy(playerId?: string, name?: string, avatarUrl?: Nullable<string>, isBot?: boolean, initialLuckyFactor?: Nullable<number>, payload?: Nullable<any>): com.logic.data.models.player.GameUserInfo;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -78,10 +77,23 @@ export declare namespace com.logic.data.models.player {
         get name(): "LIVE" | "TIMEOUT" | "LOST_CONNECTION" | "LEFT" | "DISCONNECTING" | "DELETED";
         get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
         static get Companion(): {
-            serializer(): any/* kotlinx.serialization.KSerializer<com.logic.data.models.player.PlayerConnectionState> */;
         } & 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);
@@ -118,6 +130,7 @@ 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;
@@ -231,7 +244,6 @@ export declare namespace com.logic.utils.logger.outputs {
         get name(): "DEBUG" | "ERROR" | "WARN";
         get ordinal(): 0 | 1 | 2;
         static get Companion(): {
-            serializer(): any/* kotlinx.serialization.KSerializer<com.logic.utils.logger.outputs.LogType> */;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
@@ -248,9 +260,9 @@ export declare namespace com.logic.utils.logger.outputs {
 }
 export declare namespace com.logic.utils.logger.outputs {
     interface LoggerOutput {
-        d(tag?: Nullable<string>, message: string, payload?: Nullable<any>): void;
+        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: string, 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;
         };
@@ -277,12 +289,8 @@ export declare namespace com.logic.utils.logger.outputs {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static LoggerOutputDataDto_init_$Create$(seen1: number, type: Nullable<com.logic.utils.logger.outputs.LogType>, tag: Nullable<string>, message: Nullable<string>, stackTrace: Nullable<string>, serializationConstructorMarker: Nullable<any>/* Nullable<kotlinx.serialization.internal.SerializationConstructorMarker> */): com.logic.utils.logger.outputs.LoggerOutputDataDto;
         static get Companion(): {
-            serializer(): any/* kotlinx.serialization.KSerializer<com.logic.utils.logger.outputs.LoggerOutputDataDto> */;
         };
-        static get $serializer(): {
-        } & any/* kotlinx.serialization.internal.GeneratedSerializer<com.logic.utils.logger.outputs.LoggerOutputDataDto> */;
     }
 }
 export declare namespace com.debertz.logic {
@@ -333,10 +341,32 @@ export declare namespace com.debertz.logic.data.models {
         get name(): "CREATED" | "CREATING" | "FINISHING" | "FINISHED";
         get ordinal(): 0 | 1 | 2 | 3;
         static get Companion(): {
-            serializer(): any/* kotlinx.serialization.KSerializer<com.debertz.logic.data.models.GameLifecycleState> */;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
+export declare namespace com.debertz.logic.data.models {
+    class LogicReduxConfig {
+        constructor(supportBackwardActions?: boolean, supportPlayerTurnActions?: boolean, validateTestMode?: boolean, cards?: Nullable<Array<number>>, dealer?: com.debertz.logic.data.models.DealerConfig);
+        get supportBackwardActions(): boolean;
+        get supportPlayerTurnActions(): boolean;
+        get validateTestMode(): boolean;
+        get cards(): Nullable<Array<number>>;
+        get dealer(): com.debertz.logic.data.models.DealerConfig;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(supportBackwardActions?: boolean, supportPlayerTurnActions?: boolean, validateTestMode?: boolean, cards?: Nullable<Array<number>>, dealer?: com.debertz.logic.data.models.DealerConfig): com.debertz.logic.data.models.LogicReduxConfig;
+        toString(): string;
+    }
+    class DealerConfig {
+        constructor(dealerStrategy?: com.debertz.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean);
+        get dealerStrategy(): com.debertz.logic.domain.interactors.dealer.DealerStrategy;
+        get isBotsAreHappy(): boolean;
+        copy(dealerStrategy?: com.debertz.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean): com.debertz.logic.data.models.DealerConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
 export declare namespace com.debertz.logic.data.models.scenes {
     interface ActData {
         readonly actId: string;
@@ -366,6 +396,7 @@ export declare namespace com.debertz.logic.data.models.table {
         get bribes(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */;
         get cardDeck(): Nullable<any>/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */;
         get gameInfo(): any/* com.debertz.logic.data.models.table.GameInfo */;
+        get gameDuration(): any/* kotlin.time.Duration */;
         get playersConnections(): any/* kotlin.collections.List<kotlin.Pair<string, com.logic.data.models.player.PlayerConnectionState>> */;
         get users(): Array<com.logic.data.models.player.GameUserInfo>;
         get isCardDeckExist(): boolean;
@@ -392,11 +423,11 @@ export declare namespace com.debertz.logic.data.models.table {
         readonly __doNotUseOrImplementIt: com.logic.utils.logger.game.LoggerPayload["__doNotUseOrImplementIt"];
     }
     class PlayerLoggerPayload implements com.logic.utils.logger.game.LoggerPayload {
-        constructor(playerId: string, connectionState: com.logic.data.models.player.PlayerConnectionState);
+        constructor(playerId: string, connectionState: Nullable<com.logic.data.models.player.PlayerConnectionState>);
         get playerId(): string;
-        get connectionState(): com.logic.data.models.player.PlayerConnectionState;
+        get connectionState(): Nullable<com.logic.data.models.player.PlayerConnectionState>;
         toString(): string;
-        copy(playerId?: string, connectionState?: com.logic.data.models.player.PlayerConnectionState): com.debertz.logic.data.models.table.PlayerLoggerPayload;
+        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"];
@@ -430,7 +461,6 @@ export declare namespace com.debertz.logic.data.models.table.config {
         get name(): "SUPER_HARD" | "HARD" | "MEDIUM" | "EASY" | "SUPER_EASY";
         get ordinal(): 0 | 1 | 2 | 3 | 4;
         static get Companion(): {
-            serializer(): any/* kotlinx.serialization.KSerializer<com.debertz.logic.data.models.table.config.BotIntelligenceLevel> */;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
     function getLevel(_this_: com.debertz.logic.data.models.table.config.BotIntelligenceLevel): number;
@@ -469,7 +499,7 @@ 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 players(): number;
+        get value(): number;
         static get TWO_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
             get name(): "TWO_PLAYERS";
             get ordinal(): 0;
@@ -494,14 +524,13 @@ export declare namespace com.debertz.logic.data.models.table.config {
         get ordinal(): 0 | 1 | 2 | 3;
         static get Companion(): {
             create(points: number): com.debertz.logic.data.models.table.config.PlayersMode;
-            serializer(): any/* kotlinx.serialization.KSerializer<com.debertz.logic.data.models.table.config.PlayersMode> */;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
 export declare namespace com.debertz.logic.data.models.table.config {
     abstract class PointsMode {
         private constructor();
-        get points(): number;
+        get value(): number;
         static get SMALL(): com.debertz.logic.data.models.table.config.PointsMode & {
             get name(): "SMALL";
             get ordinal(): 0;
@@ -524,7 +553,6 @@ export declare namespace com.debertz.logic.data.models.table.config {
         get ordinal(): 0 | 1 | 2 | 3;
         static get Companion(): {
             create(points: number): com.debertz.logic.data.models.table.config.PointsMode;
-            serializer(): any/* kotlinx.serialization.KSerializer<com.debertz.logic.data.models.table.config.PointsMode> */;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
@@ -612,7 +640,6 @@ export declare namespace com.debertz.logic.redux.actions.client.to {
         get name(): "ROOM_ALL" | "ROOM_EXCEPT_USER" | "USER";
         get ordinal(): 0 | 1 | 2;
         static get Companion(): {
-            serializer(): any/* kotlinx.serialization.KSerializer<com.debertz.logic.redux.actions.client.to.ActionDeliveryType> */;
         } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
@@ -639,12 +666,12 @@ export declare namespace com.debertz.logic.redux.actions.game {
         get gameNumber(): number;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        copy(roomId?: string, partyNumber?: number, players?: Array<string>, isFirstParty?: boolean, gameNumber?: number): com.debertz.logic.redux.actions.game.PartyStartedAction;
         toString(): string;
+        copy(roomId?: string, partyNumber?: number, players?: Array<string>, isFirstParty?: boolean, gameNumber?: number): com.debertz.logic.redux.actions.game.PartyStartedAction;
         get actionTag(): string;
     }
     class PartyEndedAction extends com.debertz.logic.redux.actions.game.GameAction {
-        constructor(roomId: string, partyNumber: number, earnedBiggestPointPlayerId: string, partyLosers: Array<string>, partyWinners: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>);
+        constructor(roomId: string, partyNumber: number, earnedBiggestPointPlayerId: string, partyLosers: Array<string>, partyWinners: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>, luckyFactors?: Nullable<Array<com.logic.data.models.player.PlayerLuckyFactor>>);
         get roomId(): string;
         get partyNumber(): number;
         get earnedBiggestPointPlayerId(): string;
@@ -652,11 +679,12 @@ export declare namespace com.debertz.logic.redux.actions.game {
         get partyWinners(): Array<string>;
         get gameLosers(): Nullable<Array<string>>;
         get gameWinners(): Nullable<Array<string>>;
+        get luckyFactors(): Nullable<Array<com.logic.data.models.player.PlayerLuckyFactor>>;
         get isGameFinished(): boolean;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        copy(roomId?: string, partyNumber?: number, earnedBiggestPointPlayerId?: string, partyLosers?: Array<string>, partyWinners?: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>): com.debertz.logic.redux.actions.game.PartyEndedAction;
         toString(): string;
+        copy(roomId?: string, partyNumber?: number, earnedBiggestPointPlayerId?: string, partyLosers?: Array<string>, partyWinners?: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>, luckyFactors?: Nullable<Array<com.logic.data.models.player.PlayerLuckyFactor>>): com.debertz.logic.redux.actions.game.PartyEndedAction;
         get actionTag(): string;
     }
     class PartyRestartedAction implements com.logic.domain.engine.definitions.Action {
@@ -772,6 +800,7 @@ export declare namespace com.debertz.logic.client.domain.mechanic {
         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> */;
@@ -814,6 +843,7 @@ export declare namespace com.debertz.logic.client.domain.mechanic.online {
         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> */;
@@ -846,7 +876,7 @@ export declare namespace com.debertz.logic.client.domain.mechanic.online {
 }
 export declare namespace com.debertz.logic.client.redux.state {
     class ErrorState {
-        constructor(message?: Nullable<string>, userInfo?: Nullable<com.logic.data.models.player.GameUserInfo>, reason: com.logic.data.models.TerminationGameReason);
+        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;
@@ -878,6 +908,22 @@ 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 declare namespace com.debertz.logic.server.data.models {
+    class ServerReduxConfig {
+        constructor(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number);
+        get finishGameIfAllBots(): boolean;
+        get waitForPlayerToReconnect(): boolean;
+        get waitForPlayerToReconnectTimeOutMillis(): number;
+        get closeIfBotsAtFinish(): boolean;
+        get botReplacesPlayerAfterTimeout(): boolean;
+        get enabledCombinedEvents(): boolean;
+        get delayToAskBotMillis(): number;
+        copy(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number): com.debertz.logic.server.data.models.ServerReduxConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
 export declare namespace com.debertz.logic.server.domain {
     interface ServerGameEngineContract extends com.debertz.logic.GameStoreContract {
         roomOnCreate(roomId: string, gameCreatorId: string, config: com.debertz.logic.data.models.table.config.Config, users: Array<com.logic.data.models.player.GameUserInfo>): void;
@@ -886,6 +932,7 @@ export declare namespace com.debertz.logic.server.domain {
         playerLive(playerId: string): void;
         playerLeft(playerId: string): void;
         fromClientEvent(action: com.debertz.logic.redux.actions.client.from.FromClientAction): void;
+        subscribeToClientAction(subscriber: (p0: com.debertz.logic.redux.actions.client.to.ToClientAction) => void): void;
         subscribeWith(subscriber: (p0: any/* com.debertz.logic.redux.AppState */) => void): void;
         clear(): void;
         setCanStartNewGameEnabled(enabled: boolean): void;
@@ -901,6 +948,7 @@ export declare namespace com.debertz.logic.server.domain {
 }
 export declare interface GameHelper {
     filterLivePlayers(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
+    filterLiveDuringGamePlayers(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
     filterBotPlayers(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
     filterRealPlayers(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
     getUserSocketId(store: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, playerId: string): Nullable<string>;
@@ -934,7 +982,7 @@ export declare interface GameEngineController {
     readonly resources: GameResources;
     setEnableLogger(enabled: boolean): void;
     createGameEngine(): com.debertz.logic.server.domain.ServerGameEngineContract;
-    createGameEngineWithLogic(reducers?: Array<(p0: any/* com.debertz.logic.redux.AppState */, p1: any) => any/* com.debertz.logic.redux.AppState */>, middlewares?: Array<(p0: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, p1: (p0: com.logic.domain.engine.definitions.Action) => void, p2: any) => void>, isPrivateRoom?: boolean, finishGameIfAllBots?: boolean, closeIfBotsAtFinish?: boolean, dealerConfig?: any/* com.debertz.logic.data.models.DealerConfig */): com.debertz.logic.server.domain.ServerGameEngineContract;
+    createGameEngineWithLogic(reducers?: Array<(p0: any/* com.debertz.logic.redux.AppState */, p1: any) => any/* com.debertz.logic.redux.AppState */>, middlewares?: Array<(p0: com.logic.domain.engine.definitions.Store<any/* com.debertz.logic.redux.AppState */>, p1: (p0: com.logic.domain.engine.definitions.Action) => void, p2: any) => void>, serverConfig?: com.debertz.logic.server.data.models.ServerReduxConfig, logicConfig?: com.debertz.logic.data.models.LogicReduxConfig): com.debertz.logic.server.domain.ServerGameEngineContract;
     readonly __doNotUseOrImplementIt: {
         readonly GameEngineController: unique symbol;
     };