game_client_logic_deb 1.6.38 → 1.6.56

package/Logic_Debertz-game_client.d.ts

@@ -4,6 +4,19 @@ export declare namespace com.logic {
         get version(): string;
     };
 }
+export declare namespace com.logic.data.models {
+    class CoreConfig {
+        constructor(fileLogsEnabled?: boolean, deleteFilesOnClear?: boolean, logsDirectoryPath?: Nullable<string>, fileNameFormat?: string);
+        get fileLogsEnabled(): boolean;
+        get deleteFilesOnClear(): boolean;
+        get logsDirectoryPath(): Nullable<string>;
+        get fileNameFormat(): string;
+        copy(fileLogsEnabled?: boolean, deleteFilesOnClear?: boolean, logsDirectoryPath?: Nullable<string>, fileNameFormat?: string): com.logic.data.models.CoreConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
 export declare namespace com.logic.data.models {
     abstract class TerminationGameReason {
         protected constructor();
@@ -268,38 +281,18 @@ export declare namespace com.logic.data.models.serializable.rules {
         };
     }
 }
-export declare namespace com.logic.domain.engine.definitions {
-    interface Action {
-        readonly actionTag: string;
-        readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.domain.engine.definitions.Action": unique symbol;
-        };
-    }
-}
-export declare namespace com.logic.domain.engine.definitions {
-    interface Store<State> {
-        readonly store: com.logic.domain.engine.definitions.Store<State>;
-        dispatch: (p0: com.logic.domain.engine.definitions.Action) => void;
-        readonly observe: any/* kotlinx.coroutines.flow.Flow<State> */;
-        readonly replaceReducer: (p0: any/* com.logic.domain.engine.definitions.Reducer<State> */) => void;
-        readonly state: State;
-        readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.domain.engine.definitions.Store": unique symbol;
-        };
-    }
-}
 export declare namespace com.logic.redux.actions {
-    interface BufferedAction extends com.logic.domain.engine.definitions.Action {
+    interface BufferedAction extends com.logic.redux.store.definitions.Action {
         readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.redux.actions.BufferedAction": unique symbol;
-        } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
-    interface ReleaseBufferTriggerAction extends com.logic.domain.engine.definitions.Action {
+    interface ReleaseBufferTriggerAction extends com.logic.redux.store.definitions.Action {
         readonly actionTag: string;
         readonly __doNotUseOrImplementIt: {
             readonly "com.logic.redux.actions.ReleaseBufferTriggerAction": unique symbol;
-        } & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace com.logic.redux.actions.validation {
@@ -318,6 +311,26 @@ export declare namespace com.logic.redux.actions.validation {
         };
     }
 }
+export declare namespace com.logic.redux.store.definitions {
+    interface Action {
+        readonly actionTag: string;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.redux.store.definitions.Action": unique symbol;
+        };
+    }
+}
+export declare namespace com.logic.redux.store.definitions {
+    interface Store<State> {
+        readonly store: com.logic.redux.store.definitions.Store<State>;
+        dispatch: (p0: com.logic.redux.store.definitions.Action) => void;
+        readonly observe: any/* kotlinx.coroutines.flow.Flow<State> */;
+        readonly replaceReducer: (p0: any/* com.logic.redux.store.definitions.Reducer<State> */) => void;
+        readonly state: State;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.redux.store.definitions.Store": unique symbol;
+        };
+    }
+}
 export declare namespace com.logic.utils.logger.game {
     interface GameLogger extends com.logic.utils.logger.outputs.LoggerOutput {
         d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
@@ -396,6 +409,7 @@ export declare namespace com.logic.utils.logger.outputs {
         get tag(): Nullable<string>;
         get message(): Nullable<string>;
         get stackTrace(): Nullable<string>;
+        toMessageLog(): string;
         copy(type?: com.logic.utils.logger.outputs.LogType, tag?: Nullable<string>, message?: Nullable<string>, stackTrace?: Nullable<string>): com.logic.utils.logger.outputs.LoggerOutputDataDto;
         toString(): string;
         hashCode(): number;
@@ -762,15 +776,15 @@ export declare namespace com.debertz.logic.redux.actions {
         get actionTag(): string;
         notValidateWhenFinishing(): boolean;
         notValidateWhenFinished(): boolean;
-        readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
-    } & com.logic.domain.engine.definitions.Action & com.logic.redux.actions.validation.NotValidateIfGameFinishing & com.logic.redux.actions.validation.NotValidateIfGameFinished;
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
+    } & com.logic.redux.store.definitions.Action & com.logic.redux.actions.validation.NotValidateIfGameFinishing & com.logic.redux.actions.validation.NotValidateIfGameFinished;
 }
 export declare namespace com.debertz.logic.redux.actions.client.from {
-    abstract class FromClientAction implements com.logic.domain.engine.definitions.Action {
+    abstract class FromClientAction implements com.logic.redux.store.definitions.Action {
         protected constructor();
         abstract get playerId(): string;
         get actionTag(): string;
-        readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace com.debertz.logic.redux.actions.client.to {
@@ -785,8 +799,8 @@ export declare namespace com.debertz.logic.redux.actions.client.to {
         get excludePlayerId(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        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;
         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(): {
             user(tableId: string, sendToPlayerId: string): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
         };
@@ -814,18 +828,18 @@ export declare namespace com.debertz.logic.redux.actions.client.to {
     }
 }
 export declare namespace com.debertz.logic.redux.actions.client.to {
-    abstract class ToClientAction implements com.logic.domain.engine.definitions.Action {
+    abstract class ToClientAction implements com.logic.redux.store.definitions.Action {
         protected constructor();
         abstract get deliveryPayload(): com.debertz.logic.redux.actions.client.to.ActionDeliveryPayload;
         get actionTag(): string;
-        readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace com.debertz.logic.redux.actions.game {
-    abstract class GameAction implements com.logic.domain.engine.definitions.Action {
+    abstract class GameAction implements com.logic.redux.store.definitions.Action {
         protected constructor();
         get actionTag(): string;
-        readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
     class RoundStartedAction extends com.debertz.logic.redux.actions.game.GameAction {
         constructor(id: string, gameId: string, roundNumber: number, players: Array<string>, isFirstRound: boolean, gameNumber: number, gameHistory: com.debertz.logic.data.models.table.history.GameHistory);
@@ -861,7 +875,7 @@ export declare namespace com.debertz.logic.redux.actions.game {
         copy(id?: string, gameId?: string, roundNumber?: number, earnedBiggestPointPlayerId?: string, roundCommitted?: Array<string>, 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;
         get actionTag(): string;
     }
-    class PartyRestartedAction implements com.logic.domain.engine.definitions.Action {
+    class PartyRestartedAction implements com.logic.redux.store.definitions.Action {
         constructor(id: string, roundNumber: number);
         get id(): string;
         get partyNumber(): number;
@@ -870,7 +884,7 @@ export declare namespace com.debertz.logic.redux.actions.game {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
-        readonly __doNotUseOrImplementIt: com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace com.debertz.logic.redux.actions.mechanic {
@@ -879,6 +893,41 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: com.logic.redux.actions.BufferedAction["__doNotUseOrImplementIt"];
     }
+    interface FirstMechanicAction extends com.logic.redux.store.definitions.Action {
+        readonly id: string;
+        readonly version: string;
+        readonly users: any/* kotlin.collections.List<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"];
+    }
+    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> */);
+        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;
+        toString(): string;
+        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.FirstMechanicAction["__doNotUseOrImplementIt"];
+    }
+    class StartNewGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction {
+        constructor(previousGameId: string, gameId: string);
+        get previousGameId(): string;
+        get gameId(): string;
+        copy(previousGameId?: string, gameId?: string): com.debertz.logic.redux.actions.mechanic.StartNewGameMechanicAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+    }
     class FinishingGameMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.TerminatedAction {
         constructor(reason: com.logic.data.models.TerminationGameReason);
         get reason(): com.logic.data.models.TerminationGameReason;
@@ -900,16 +949,16 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         notValidateWhenFinishing(): boolean;
         readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.debertz.logic.redux.actions.mechanic.TerminatedAction["__doNotUseOrImplementIt"];
     }
-    interface NavigationMechanicAction extends com.logic.domain.engine.definitions.Action {
+    interface NavigationMechanicAction extends com.logic.redux.store.definitions.Action {
         readonly sceneId: string;
         readonly actId: Nullable<string>;
         readonly actPayload: 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.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
-    class SceneMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction, com.logic.domain.engine.definitions.Action, com.logic.redux.actions.ReleaseBufferTriggerAction, com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished/*, com.debertz.logic.redux.actions.mechanic.NextPlayerTurnAction */ {
+    class SceneMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction, com.logic.redux.store.definitions.Action, com.logic.redux.actions.ReleaseBufferTriggerAction, com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished/*, com.debertz.logic.redux.actions.mechanic.NextPlayerTurnAction */ {
         constructor(sceneId: string, actId?: Nullable<string>, scenePayload?: Nullable<com.debertz.logic.data.models.scenes.SceneData>, actPayload?: Nullable<com.debertz.logic.data.models.scenes.ActData>);
         get sceneId(): string;
         get actId(): Nullable<string>;
@@ -922,14 +971,14 @@ export declare namespace com.debertz.logic.redux.actions.mechanic {
         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.NavigationMechanicAction["__doNotUseOrImplementIt"] & com.logic.domain.engine.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.ReleaseBufferTriggerAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
+        readonly __doNotUseOrImplementIt: com.debertz.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.ReleaseBufferTriggerAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
     }
-    interface TerminatedAction extends com.logic.domain.engine.definitions.Action {
+    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.domain.engine.definitions.Action["__doNotUseOrImplementIt"];
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
     class PlayerConnectionChangedMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished {
         constructor(playerId: string, state: com.logic.data.models.player.PlayerConnectionState, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>);
@@ -961,6 +1010,8 @@ export declare interface ParserHelper {
     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;
+    encodeGameRound(round: com.debertz.logic.data.models.table.history.RoundHistory): string;
+    encodeGameRoundItems(round: com.debertz.logic.data.models.table.history.RoundHistory): string;
     readonly __doNotUseOrImplementIt: {
         readonly ParserHelper: unique symbol;
     };
@@ -1054,6 +1105,7 @@ export declare namespace com.debertz.logic.client.domain.mechanic {
         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;
@@ -1097,6 +1149,7 @@ export declare namespace com.debertz.logic.client.domain.mechanic.online {
         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;
@@ -1119,14 +1172,14 @@ export declare namespace com.debertz.logic.client.redux.state {
     }
 }
 export declare namespace com.debertz.logic.client.utils {
-    interface ShowClientErrorLoggerOutput extends com.logic.utils.logger.outputs.LoggerOutput {
+    interface ShowErrorLoggerOutput extends com.logic.utils.logger.outputs.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.ShowClientErrorLoggerOutput": unique symbol;
+            readonly "com.debertz.logic.client.utils.ShowErrorLoggerOutput": unique symbol;
         } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"];
     }
 }
@@ -1134,7 +1187,7 @@ export declare interface GameClientEngineController {
     readonly parser: ParserHelper;
     setEnableLogger(enabled: boolean): void;
     createOnlineGameEngine(currentPlayerId: string): com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic;
-    createOnlineGameEngineWithLogic(currentPlayerId: string, 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>, isAutoStepCurrentPlayer?: boolean, botExitsWhenNGameNumberIsFinished?: Nullable<number>): com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic;
+    createOnlineGameEngineWithLogic(currentPlayerId: string, reducers?: Array<(p0: any/* com.debertz.logic.redux.AppState */, p1: any) => any/* com.debertz.logic.redux.AppState */>, middlewares?: Array<(p0: com.logic.redux.store.definitions.Store<any/* com.debertz.logic.redux.AppState */>, p1: (p0: com.logic.redux.store.definitions.Action) => void, p2: any) => void>, isAutoStepCurrentPlayer?: boolean, botExitsWhenNGameNumberIsFinished?: Nullable<number>): com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic;
     readonly __doNotUseOrImplementIt: {
         readonly GameClientEngineController: unique symbol;
     };