game_client_logic_deb 1.8.185 → 1.8.225

package/Logic_Debertz-game_client.d.ts

@@ -6,18 +6,27 @@ export declare namespace kotlin.collections {
             readonly "kotlin.collections.KtList": unique symbol;
         };
     }
+    const KtList: {
+        fromJsArray<E>(array: ReadonlyArray<E>): kotlin.collections.KtList<E>;
+    };
     interface KtSet<E> /* extends kotlin.collections.Collection<E> */ {
         asJsReadonlySetView(): ReadonlySet<E>;
         readonly __doNotUseOrImplementIt: {
             readonly "kotlin.collections.KtSet": unique symbol;
         };
     }
+    const KtSet: {
+        fromJsSet<E>(set: ReadonlySet<E>): kotlin.collections.KtSet<E>;
+    };
     interface KtMap<K, V> {
         asJsReadonlyMapView(): ReadonlyMap<K, V>;
         readonly __doNotUseOrImplementIt: {
             readonly "kotlin.collections.KtMap": unique symbol;
         };
     }
+    const KtMap: {
+        fromJsMap<K, V>(map: ReadonlyMap<K, V>): kotlin.collections.KtMap<K, V>;
+    };
 }
 export declare namespace games.raspberry.logger {
     interface LoggerEnabledTrigger extends games.raspberry.logger.RaspberryLogger {
@@ -132,6 +141,20 @@ export declare namespace games.raspberry.card_game.random.data.models {
         equals(other: Nullable<any>): boolean;
     }
 }
+export declare namespace games.raspberry.card_game.random.data.providers {
+    class PoolParams {
+        constructor(poolSize?: number, thresholdForUsedPool?: number, requestDurationWarn?: number, failedRequestAttempts?: number, failedAttemptCooldown?: any/* kotlin.time.Duration */);
+        get poolSize(): number;
+        get thresholdForUsedPool(): number;
+        get requestDurationWarn(): number;
+        get failedRequestAttempts(): number;
+        get failedAttemptCooldown(): any/* kotlin.time.Duration */;
+        copy(poolSize?: number, thresholdForUsedPool?: number, requestDurationWarn?: number, failedRequestAttempts?: number, failedAttemptCooldown?: any/* kotlin.time.Duration */): games.raspberry.card_game.random.data.providers.PoolParams;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
 export declare namespace io.raspberryapps.cardgame.core {
     const CoreConfig: {
         get version(): string;
@@ -222,16 +245,20 @@ export declare namespace com.logic.data.models {
                 get name(): "PLAYER_DELETED";
                 get ordinal(): 1;
             };
+            static get FINISHED(): com.logic.data.models.GameFinishedReason.Reason & {
+                get name(): "FINISHED";
+                get ordinal(): 2;
+            };
             static get NO_ACTIVE_PLAYERS(): com.logic.data.models.GameFinishedReason.Reason & {
                 get name(): "NO_ACTIVE_PLAYERS";
-                get ordinal(): 2;
+                get ordinal(): 3;
             };
             static get GAME_NOT_EXISTS(): com.logic.data.models.GameFinishedReason.Reason & {
                 get name(): "GAME_NOT_EXISTS";
-                get ordinal(): 3;
+                get ordinal(): 4;
             };
-            get name(): "DEPLOY" | "PLAYER_DELETED" | "NO_ACTIVE_PLAYERS" | "GAME_NOT_EXISTS";
-            get ordinal(): 0 | 1 | 2 | 3;
+            get name(): "DEPLOY" | "PLAYER_DELETED" | "FINISHED" | "NO_ACTIVE_PLAYERS" | "GAME_NOT_EXISTS";
+            get ordinal(): 0 | 1 | 2 | 3 | 4;
             static values(): Array<com.logic.data.models.GameFinishedReason.Reason>;
             static valueOf(value: string): com.logic.data.models.GameFinishedReason.Reason;
             static get Companion(): {
@@ -509,14 +536,17 @@ export declare namespace games.jass.logic.data.models {
 }
 export declare namespace games.jass.logic.data.models {
     class EngineLogicConfig {
-        constructor(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, gameHistoryAnalytics?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number);
+        constructor(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, gameHistoryAnalytics?: boolean, validateFromClientActionTags?: boolean, validateIfMainThread?: boolean, playerTimeoutFactorToFinishStep?: number, openRoomIfFinished?: boolean, minPlayersToOpenRoom?: number);
         get supportBackwardActions(): boolean;
         get validateTestMode(): boolean;
         get verboseGameHistory(): boolean;
         get gameHistoryMetadata(): boolean;
         get validateFromClientActionTags(): boolean;
+        get validateIfMainThread(): boolean;
         get playerTimeoutFactorToFinishStep(): number;
-        copy(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, gameHistoryAnalytics?: boolean, validateFromClientActionTags?: boolean, playerTimeoutFactorToFinishStep?: number): games.jass.logic.data.models.EngineLogicConfig;
+        get openRoomIfFinished(): boolean;
+        get minPlayersToOpenRoom(): number;
+        copy(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, gameHistoryAnalytics?: boolean, validateFromClientActionTags?: boolean, validateIfMainThread?: boolean, playerTimeoutFactorToFinishStep?: number, openRoomIfFinished?: boolean, minPlayersToOpenRoom?: number): games.jass.logic.data.models.EngineLogicConfig;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -601,10 +631,15 @@ export declare namespace games.jass.logic.data.models.config {
 }
 export declare namespace games.jass.logic.data.models.dealer {
     class RandomData {
-        constructor(signature: Nullable<string>, id: string, indexes: kotlin.collections.KtList<number>);
+        constructor(signature: Nullable<string>, id: string, indexes: kotlin.collections.KtList<number>, provider: games.jass.logic.domain.interactors.dealer.DealerStrategy);
         get signature(): Nullable<string>;
         get id(): string;
         get indexes(): kotlin.collections.KtList<number>;
+        get provider(): games.jass.logic.domain.interactors.dealer.DealerStrategy;
+        copy(signature?: Nullable<string>, id?: string, indexes?: kotlin.collections.KtList<number>, provider?: games.jass.logic.domain.interactors.dealer.DealerStrategy): games.jass.logic.data.models.dealer.RandomData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
     }
 }
 export declare namespace games.jass.logic.data.models.messages.combinatios {
@@ -1402,21 +1437,22 @@ export declare namespace games.jass.logic.redux.actions.client.from {
 }
 export declare namespace games.jass.logic.redux.actions.client.to {
     class ActionDeliveryPayload {
-        constructor(id: string, includePlayers: Array<string>, excludePlayers: Array<string>, deliveryType: games.jass.logic.redux.actions.client.to.ActionDeliveryType);
+        constructor(tableId: string, aid: string, includePlayers: Array<string>, excludePlayers: Array<string>, deliveryType: games.jass.logic.redux.actions.client.to.ActionDeliveryType);
         get id(): string;
+        get aid(): string;
         get includePlayers(): Array<string>;
         get excludePlayers(): Array<string>;
         get deliveryType(): games.jass.logic.redux.actions.client.to.ActionDeliveryType;
         get excludePlayerOrNull(): Nullable<string>;
         get sendToPlayerId(): string;
         get excludePlayerId(): string;
+        toString(): string;
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
-        toString(): string;
-        copy(id?: string, includePlayers?: Array<string>, excludePlayers?: Array<string>, deliveryType?: games.jass.logic.redux.actions.client.to.ActionDeliveryType): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
+        copy(tableId?: string, aid?: string, includePlayers?: Array<string>, excludePlayers?: Array<string>, deliveryType?: games.jass.logic.redux.actions.client.to.ActionDeliveryType): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
         static get Companion(): {
-            userFromTable(table: games.jass.logic.data.models.table.JassTable, sendToPlayerId: string): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
-            user(tableId: string, sendToPlayerId: string): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
+            userFromTable(aid: string, table: games.jass.logic.data.models.table.JassTable, sendToPlayerId: string): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
+            user(aid: string, tableId: string, sendToPlayerId: string): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
         };
     }
     abstract class ActionDeliveryType {
@@ -1501,9 +1537,21 @@ export declare namespace games.jass.logic.redux.actions.game {
         readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
 }
+export declare namespace games.jass.logic.redux.actions.mechanic {
+    class GameToRoomTransition {
+        constructor(roomId: string, playerIds: kotlin.collections.KtList<string>);
+        get roomId(): string;
+        get playerIds(): kotlin.collections.KtList<string>;
+        copy(roomId?: string, playerIds?: kotlin.collections.KtList<string>): games.jass.logic.redux.actions.mechanic.GameToRoomTransition;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
 export declare namespace games.jass.logic.redux.actions.mechanic {
     abstract class MechanicAction implements com.logic.redux.actions.BufferedAction {
         protected constructor();
+        abstract get aid(): Nullable<string>;
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: com.logic.redux.actions.BufferedAction["__doNotUseOrImplementIt"];
     }
@@ -1518,13 +1566,14 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.IgnoreBufferForAction["__doNotUseOrImplementIt"];
     }
     class StartGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements games.jass.logic.redux.actions.mechanic.FirstMechanicAction {
-        constructor(config: games.jass.logic.data.models.table.config.Config, id: string, version: string, gameCreatorPlayerId: string, users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>);
+        constructor(config: games.jass.logic.data.models.table.config.Config, roomId: string, version: string, gameCreatorPlayerId: string, users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>, aid?: Nullable<string>);
         get config(): games.jass.logic.data.models.table.config.Config;
         get id(): string;
         get version(): string;
         get gameCreatorPlayerId(): string;
         get users(): kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>;
-        copy(config?: games.jass.logic.data.models.table.config.Config, id?: string, version?: string, gameCreatorPlayerId?: string, users?: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>): games.jass.logic.redux.actions.mechanic.StartGameMechanicAction;
+        get aid(): Nullable<string>;
+        copy(config?: games.jass.logic.data.models.table.config.Config, roomId?: string, version?: string, gameCreatorPlayerId?: string, users?: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.StartGameMechanicAction;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -1532,10 +1581,11 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.FirstMechanicAction["__doNotUseOrImplementIt"];
     }
     class StartNewGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction {
-        constructor(previousGameId: string, gameId: string);
+        constructor(previousGameId: string, gameId: string, aid?: Nullable<string>);
         get previousGameId(): string;
         get gameId(): string;
-        copy(previousGameId?: string, gameId?: string): games.jass.logic.redux.actions.mechanic.StartNewGameMechanicAction;
+        get aid(): Nullable<string>;
+        copy(previousGameId?: string, gameId?: string, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.StartNewGameMechanicAction;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -1543,27 +1593,30 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
     }
     /* @ts-ignore: https://github.com/microsoft/TypeScript/issues/4628 */
     class FinishingGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements games.jass.logic.redux.actions.mechanic.TerminatedAction, com.logic.redux.actions.validation.NotValidateIfGameFinishing {
-        constructor(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, sessionAnalytics?: Nullable<games.jass.logic.data.models.GameSessionAnalytics>, gameHistory?: Nullable<games.jass.logic.data.models.table.history.GameHistory>);
+        constructor(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, transition?: Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>, sessionAnalytics?: Nullable<games.jass.logic.data.models.GameSessionAnalytics>, gameHistory?: Nullable<games.jass.logic.data.models.table.history.GameHistory>, aid?: Nullable<string>);
         get reason(): com.logic.data.models.TerminationGameReason;
         get isGameFinished(): boolean;
+        get transition(): Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>;
         get sessionAnalytics(): Nullable<games.jass.logic.data.models.GameSessionAnalytics>;
         get gameHistory(): Nullable<games.jass.logic.data.models.table.history.GameHistory>;
+        get aid(): Nullable<string>;
         toString(): string;
-        copy(reason?: com.logic.data.models.TerminationGameReason, isGameFinished?: boolean, sessionAnalytics?: Nullable<games.jass.logic.data.models.GameSessionAnalytics>, gameHistory?: Nullable<games.jass.logic.data.models.table.history.GameHistory>): games.jass.logic.redux.actions.mechanic.FinishingGameMechanicAction;
+        copy(reason?: com.logic.data.models.TerminationGameReason, isGameFinished?: boolean, transition?: Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>, sessionAnalytics?: Nullable<games.jass.logic.data.models.GameSessionAnalytics>, gameHistory?: Nullable<games.jass.logic.data.models.table.history.GameHistory>, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.FinishingGameMechanicAction;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
         notValidateWhenFinishing(): boolean;
         readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.TerminatedAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"];
         static get Companion(): {
-            withAnalytics(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, table: Nullable<games.jass.logic.data.models.table.JassTable>): games.jass.logic.redux.actions.mechanic.FinishingGameMechanicAction;
+            withAnalytics(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, table: Nullable<games.jass.logic.data.models.table.JassTable>, transition?: Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>): games.jass.logic.redux.actions.mechanic.FinishingGameMechanicAction;
         };
     }
     class FinishGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements com.logic.redux.actions.validation.NotValidateIfGameFinishing, games.jass.logic.redux.actions.mechanic.TerminatedAction {
-        constructor(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean);
+        constructor(reason: com.logic.data.models.TerminationGameReason, isGameFinished: boolean, aid?: Nullable<string>);
         get reason(): com.logic.data.models.TerminationGameReason;
         get isGameFinished(): boolean;
-        copy(reason?: com.logic.data.models.TerminationGameReason, isGameFinished?: boolean): games.jass.logic.redux.actions.mechanic.FinishGameMechanicAction;
+        get aid(): Nullable<string>;
+        copy(reason?: com.logic.data.models.TerminationGameReason, isGameFinished?: boolean, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.FinishGameMechanicAction;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
@@ -1580,15 +1633,16 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
     class SceneMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction implements games.jass.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/*, games.jass.logic.redux.actions.mechanic.NextPlayerTurnAction */ {
-        constructor(sceneId: string, actId?: Nullable<string>, sceneData?: Nullable<games.jass.logic.data.models.scenes.SceneData>, actData?: Nullable<games.jass.logic.data.models.scenes.ActData>);
+        constructor(sceneId: string, actId?: Nullable<string>, sceneData?: Nullable<games.jass.logic.data.models.scenes.SceneData>, actData?: Nullable<games.jass.logic.data.models.scenes.ActData>, aid?: Nullable<string>);
         get sceneId(): string;
         get actId(): Nullable<string>;
         get sceneData(): Nullable<games.jass.logic.data.models.scenes.SceneData>;
         get actData(): Nullable<games.jass.logic.data.models.scenes.ActData>;
+        get aid(): Nullable<string>;
         notValidateWhenFinished(): boolean;
         notValidateWhenFinishing(): boolean;
         toString(): string;
-        copy(sceneId?: string, actId?: Nullable<string>, sceneData?: Nullable<games.jass.logic.data.models.scenes.SceneData>, actData?: Nullable<games.jass.logic.data.models.scenes.ActData>): games.jass.logic.redux.actions.mechanic.SceneMechanicAction;
+        copy(sceneId?: string, actId?: Nullable<string>, sceneData?: Nullable<games.jass.logic.data.models.scenes.SceneData>, actData?: Nullable<games.jass.logic.data.models.scenes.ActData>, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.SceneMechanicAction;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;
@@ -1602,17 +1656,17 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
     class PlayerConnectionChangedMechanicAction extends games.jass.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, causeState?: Nullable<com.logic.data.models.player.PlayerConnectionState>, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>);
+        constructor(playerId: string, state: com.logic.data.models.player.PlayerConnectionState, causeState?: Nullable<com.logic.data.models.player.PlayerConnectionState>, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>, aid?: Nullable<string>);
         get playerId(): string;
         get state(): com.logic.data.models.player.PlayerConnectionState;
         get causeState(): Nullable<com.logic.data.models.player.PlayerConnectionState>;
         get isNoneActivePlayers(): boolean;
         get reconnectUntilTime(): Nullable<string>;
+        get aid(): Nullable<string>;
         get isShouldBeDisconnectedFromSockets(): boolean;
         get isDeleted(): boolean;
-        get shouldNotifyPlayers(): boolean;
         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>): games.jass.logic.redux.actions.mechanic.PlayerConnectionChangedMechanicAction;
+        copy(playerId?: string, state?: com.logic.data.models.player.PlayerConnectionState, causeState?: Nullable<com.logic.data.models.player.PlayerConnectionState>, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.PlayerConnectionChangedMechanicAction;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         get actionTag(): string;