client_plugin_logic_deb 1.4.96 → 1.5.9

package/Logic_Debertz-client_plugin.d.ts

@@ -15,13 +15,14 @@ export declare namespace com.logic.data.models {
 }
 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;
@@ -82,6 +83,20 @@ 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);
@@ -118,6 +133,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;
@@ -337,6 +353,29 @@ export declare namespace com.debertz.logic.data.models {
         } & 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 +405,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 +432,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"];
@@ -469,7 +509,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;
@@ -501,7 +541,7 @@ 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 points(): number;
+        get value(): number;
         static get SMALL(): com.debertz.logic.data.models.table.config.PointsMode & {
             get name(): "SMALL";
             get ordinal(): 0;
@@ -583,8 +623,8 @@ export declare namespace com.debertz.logic.redux.actions.client.to {
         get excludePlayers(): Array<string>;
         get deliveryType(): com.debertz.logic.redux.actions.client.to.ActionDeliveryType;
         get excludePlayerOrNull(): Nullable<string>;
-        get playerId(): string;
-        get excludePlayer(): string;
+        get sendToPlayerId(): string;
+        get excludePlayerId(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
         copy(roomId?: string, includePlayers?: Array<string>, excludePlayers?: Array<string>, deliveryType?: com.debertz.logic.redux.actions.client.to.ActionDeliveryType): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
@@ -620,9 +660,6 @@ export declare namespace com.debertz.logic.redux.actions.client.to {
     abstract class ToClientAction implements com.logic.domain.engine.definitions.Action {
         protected constructor();
         abstract get deliveryPayload(): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
-        get sendToPlayerId(): string;
-        get sendToPlayerIds(): Array<string>;
-        get roomId(): string;
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
     }
@@ -647,7 +684,7 @@ export declare namespace com.debertz.logic.redux.actions.game {
         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;
@@ -655,10 +692,11 @@ 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;
+        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;
         toString(): string;
         get actionTag(): string;
     }
@@ -761,7 +799,7 @@ export declare interface ParserHelper {
     encodeFromClientEvent(action: com.debertz.logic.redux.actions.client.from.FromClientAction): string;
     decodeFromClientEvent(fromPlayerId: string, json: string): com.debertz.logic.redux.actions.client.from.FromClientAction;
     encodeToClientEvent(action: com.debertz.logic.redux.actions.client.to.ToClientAction): string;
-    decodeToClientEventToMechanicAction(playerId: string, engine: com.debertz.logic.GameStoreContract, json: string): com.debertz.logic.redux.actions.mechanic.MechanicAction;
+    decodeToClientEventToMechanicAction(playerId: string, engine: com.debertz.logic.GameStoreContract, json: string): Array<com.debertz.logic.redux.actions.mechanic.MechanicAction>;
     readonly __doNotUseOrImplementIt: {
         readonly ParserHelper: unique symbol;
     };
@@ -775,6 +813,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> */;
@@ -809,7 +848,7 @@ export declare namespace com.debertz.logic.client.domain.mechanic.online {
     interface OnlineGameMechanic extends com.debertz.logic.client.domain.mechanic.GameMechanic {
         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;
+        mechanicAction(action: Array<com.debertz.logic.redux.actions.mechanic.MechanicAction>): void;
         onCreate(): void;
         onDestroy(): void;
         getConfig(): com.debertz.logic.data.models.table.config.Config;
@@ -817,6 +856,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> */;
@@ -881,6 +921,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;
@@ -889,6 +945,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;
@@ -904,6 +961,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>;
@@ -937,7 +995,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, dealerStrategy?: com.debertz.logic.domain.interactors.dealer.DealerStrategy): 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;
     };