game_client_logic_deb 1.3.47

package/Logic_Debertz-game_client_logic_deb.d.ts

@@ -0,0 +1,592 @@
+type Nullable<T> = T | null | undefined
+declare const __doNotImplementIt: unique symbol
+type __doNotImplementIt = typeof __doNotImplementIt
+export namespace com.logic {
+    const GameEngineConfig: {
+        get version(): string;
+    };
+}
+export namespace com.logic.data.models {
+    abstract class TerminationGameReason {
+        protected constructor();
+        static TerminationGameReason_init_$Create$(seen1: number, serializationConstructorMarker: 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 namespace com.logic.data.models.player {
+    class GameUserInfo implements com.logic.data.models.player.PlayerIdContract {
+        constructor(playerId: string, name: string, avatarUrl: string, payload?: Nullable<any>);
+        get playerId(): string;
+        get name(): string;
+        get avatarUrl(): string;
+        get payload(): Nullable<any>;
+        component1(): string;
+        component2(): string;
+        component3(): string;
+        component4(): Nullable<any>;
+        copy(playerId?: string, name?: string, avatarUrl?: string, payload?: Nullable<any>): com.logic.data.models.player.GameUserInfo;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export namespace com.logic.data.models.player {
+    interface PlayerIdContract {
+        readonly playerId: string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+    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;
+}
+export namespace com.logic.data.models.player {
+    abstract class PlayerConnectionState {
+        private constructor();
+        static get LIVE(): com.logic.data.models.player.PlayerConnectionState & {
+            get name(): "LIVE";
+            get ordinal(): 0;
+        };
+        static get TIMEOUT(): com.logic.data.models.player.PlayerConnectionState & {
+            get name(): "TIMEOUT";
+            get ordinal(): 1;
+        };
+        static get LOST_CONNECTION(): com.logic.data.models.player.PlayerConnectionState & {
+            get name(): "LOST_CONNECTION";
+            get ordinal(): 2;
+        };
+        static get LEFT(): com.logic.data.models.player.PlayerConnectionState & {
+            get name(): "LEFT";
+            get ordinal(): 3;
+        };
+        static get DISCONNECTING(): com.logic.data.models.player.PlayerConnectionState & {
+            get name(): "DISCONNECTING";
+            get ordinal(): 4;
+        };
+        static get DELETED(): com.logic.data.models.player.PlayerConnectionState & {
+            get name(): "DELETED";
+            get ordinal(): 5;
+        };
+        get isLive(): boolean;
+        get isTimeOut(): boolean;
+        get isLostConnection(): boolean;
+        get isLeft(): boolean;
+        get isDeleted(): boolean;
+        get isDisconnecting(): boolean;
+        get isNotAlive(): boolean;
+        get isPossibleToBeLive(): 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;
+    }
+}
+export namespace com.logic.data.models.rules {
+    class Rules {
+        constructor(needToPutHigherTrump: boolean, distributePoints: boolean, protectBella: 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);
+        get needToPutHigherTrump(): boolean;
+        get distributePoints(): boolean;
+        get protectBella(): boolean;
+        get enableFourSevensCombination(): boolean;
+        get enableTrumpSevenCombination(): boolean;
+        get enableTrumpSevenCombinationAfterDistribution(): boolean;
+        get playerWhoChooseSuitGoFirst(): boolean;
+        get winnerShuffleCards(): boolean;
+        get playWithoutLiabilities(): boolean;
+        get trumpCardGoToPlayerWhoShuffleCards(): boolean;
+        get enableFineIfNoBribes(): boolean;
+        get fineIfNoBribes(): number;
+        get enableFineAfterThirdByte(): boolean;
+        get checkTrumpCombination(): boolean;
+        get checkOnlyTrumpDebertz(): boolean;
+        get tenCardsInHand(): boolean;
+        component1(): boolean;
+        component2(): boolean;
+        component3(): boolean;
+        component4(): boolean;
+        component5(): boolean;
+        component6(): boolean;
+        component7(): boolean;
+        component8(): boolean;
+        component9(): boolean;
+        component10(): boolean;
+        component11(): boolean;
+        component12(): number;
+        component13(): boolean;
+        component14(): boolean;
+        component15(): boolean;
+        component16(): boolean;
+        copy(needToPutHigherTrump?: boolean, distributePoints?: boolean, protectBella?: 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): com.logic.data.models.rules.Rules;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            kharkiv(): com.logic.data.models.rules.Rules;
+            klabor(): com.logic.data.models.rules.Rules;
+            debertzCommon(): com.logic.data.models.rules.Rules;
+            moscow(): com.logic.data.models.rules.Rules;
+            belot(): com.logic.data.models.rules.Rules;
+            custom(): com.logic.data.models.rules.Rules;
+        };
+    }
+}
+export namespace com.logic.data.models.rules {
+    abstract class RulesSetType {
+        private constructor();
+        static get belot(): com.logic.data.models.rules.RulesSetType & {
+            get name(): "belot";
+            get ordinal(): 0;
+        };
+        static get klabor(): com.logic.data.models.rules.RulesSetType & {
+            get name(): "klabor";
+            get ordinal(): 1;
+        };
+        static get debertzCommon(): com.logic.data.models.rules.RulesSetType & {
+            get name(): "debertzCommon";
+            get ordinal(): 2;
+        };
+        static get debertzKharkiv(): com.logic.data.models.rules.RulesSetType & {
+            get name(): "debertzKharkiv";
+            get ordinal(): 3;
+        };
+        static get debertzMoscow(): com.logic.data.models.rules.RulesSetType & {
+            get name(): "debertzMoscow";
+            get ordinal(): 4;
+        };
+        static get custom(): com.logic.data.models.rules.RulesSetType & {
+            get name(): "custom";
+            get ordinal(): 5;
+        };
+        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" | "debertzMoscow" | "custom";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+    }
+}
+export namespace com.logic.domain.engine.definitions {
+    interface Action {
+        readonly actionTag: string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export namespace com.logic.domain.engine.definitions {
+    interface Store<State> {
+        readonly state: 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 __doNotUseIt: __doNotImplementIt;
+    }
+}
+export namespace com.logic.redux.actions {
+    interface BufferedAction extends com.logic.domain.engine.definitions.Action {
+        ignoreBuffer(): boolean;
+        readonly actionTag: string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+    interface ReleaseBufferTriggerAction extends com.logic.domain.engine.definitions.Action {
+        readonly actionTag: string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export namespace com.logic.utils.logger.game {
+    interface LoggerPayload {
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export namespace com.debertz.logic.data.models.scenes {
+    interface ActData {
+        readonly actId: string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export namespace com.debertz.logic.data.models.scenes {
+    interface SceneData {
+        readonly sceneId: string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export 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> */, party?: any/* com.debertz.logic.data.models.table.party.Party */, previousParty?: any/* Nullable<com.debertz.logic.data.models.table.party.PreviousParty> */, sceneInfo?: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable?: any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTheTable> */, bribes?: any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */, cardDeck?: any/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */);
+        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 party(): any/* com.debertz.logic.data.models.table.party.Party */;
+        get previousParty(): any/* Nullable<com.debertz.logic.data.models.table.party.PreviousParty> */;
+        get sceneInfo(): any/* com.debertz.logic.data.models.table.scene.SceneInfo */;
+        get cardsOnTable(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTheTable> */;
+        get bribes(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */;
+        get cardDeck(): any/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */;
+        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(): any/* Nullable<com.logic.data.models.table.cards.Suit> */;
+        component1(): string;
+        component2(): string;
+        component3(): any/* kotlinx.datetime.Instant */;
+        component4(): com.debertz.logic.data.models.table.config.Config;
+        component5(): any/* kotlin.collections.List<com.debertz.logic.data.models.player.DebertzPlayer> */;
+        component6(): any/* com.debertz.logic.data.models.table.party.Party */;
+        component7(): any/* Nullable<com.debertz.logic.data.models.table.party.PreviousParty> */;
+        component8(): any/* com.debertz.logic.data.models.table.scene.SceneInfo */;
+        component9(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTheTable> */;
+        component10(): any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */;
+        component11(): any/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */;
+        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> */, party?: any/* com.debertz.logic.data.models.table.party.Party */, previousParty?: any/* Nullable<com.debertz.logic.data.models.table.party.PreviousParty> */, sceneInfo?: any/* com.debertz.logic.data.models.table.scene.SceneInfo */, cardsOnTable?: any/* kotlin.collections.List<com.debertz.logic.data.models.table.bribes.CardOnTheTable> */, bribes?: any/* kotlin.collections.List<com.debertz.logic.data.models.table.cards.Bribe> */, cardDeck?: any/* Nullable<com.debertz.logic.data.models.table.cards.CardDeck> */): com.debertz.logic.data.models.table.DebertzTable;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export namespace com.debertz.logic.data.models.table {
+    class TableLoggerPayload implements com.logic.utils.logger.game.LoggerPayload {
+        constructor(id: string, players: Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>);
+        get id(): string;
+        get players(): Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>;
+        toString(): string;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        component1(): string;
+        component2(): Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>;
+        copy(id?: string, players?: Array<com.debertz.logic.data.models.table.PlayerLoggerPayload>): com.debertz.logic.data.models.table.TableLoggerPayload;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+    class PlayerLoggerPayload implements com.logic.utils.logger.game.LoggerPayload {
+        constructor(playerId: string, connectionState: com.logic.data.models.player.PlayerConnectionState);
+        get playerId(): string;
+        get connectionState(): com.logic.data.models.player.PlayerConnectionState;
+        toString(): string;
+        component1(): string;
+        component2(): com.logic.data.models.player.PlayerConnectionState;
+        copy(playerId?: string, connectionState?: com.logic.data.models.player.PlayerConnectionState): com.debertz.logic.data.models.table.PlayerLoggerPayload;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export namespace com.debertz.logic.data.models.table.config {
+    abstract class BotIntelligenceLevel {
+        private constructor();
+        static get SUPER_HARD(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
+            get name(): "SUPER_HARD";
+            get ordinal(): 0;
+        };
+        static get HARD(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
+            get name(): "HARD";
+            get ordinal(): 1;
+        };
+        static get MEDIUM(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
+            get name(): "MEDIUM";
+            get ordinal(): 2;
+        };
+        static get EASY(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
+            get name(): "EASY";
+            get ordinal(): 3;
+        };
+        static get SUPER_EASY(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel & {
+            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;
+    }
+    function getLevel(_this_: com.debertz.logic.data.models.table.config.BotIntelligenceLevel): number;
+}
+export namespace com.debertz.logic.data.models.table.config {
+    class Config {
+        constructor(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);
+        get rules(): com.logic.data.models.rules.Rules;
+        get rulesSetType(): com.logic.data.models.rules.RulesSetType;
+        get options(): com.debertz.logic.data.models.table.config.Options;
+        get playersMode(): com.debertz.logic.data.models.table.config.PlayersMode;
+        get pointsMode(): com.debertz.logic.data.models.table.config.PointsMode;
+        get timeoutTimeMillis(): number;
+        component1(): com.logic.data.models.rules.Rules;
+        component2(): com.logic.data.models.rules.RulesSetType;
+        component3(): com.debertz.logic.data.models.table.config.Options;
+        component4(): com.debertz.logic.data.models.table.config.PlayersMode;
+        component5(): com.debertz.logic.data.models.table.config.PointsMode;
+        component6(): 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): com.debertz.logic.data.models.table.config.Config;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export namespace com.debertz.logic.data.models.table.config {
+    class Options {
+        constructor(isEnableChat?: boolean, botIntelligenceLevel?: com.debertz.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: boolean, isEnablePreviewScreen?: boolean, botReplacesPlayerAfterTimeout?: boolean);
+        get isEnableChat(): boolean;
+        get botIntelligenceLevel(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel;
+        get timeForCountdownMillis(): number;
+        get timeForBotMillis(): number;
+        get isEnableChoosePartnerScreen(): boolean;
+        get isEnablePreviewScreen(): boolean;
+        get botReplacesPlayerAfterTimeout(): boolean;
+        component1(): boolean;
+        component2(): com.debertz.logic.data.models.table.config.BotIntelligenceLevel;
+        component3(): number;
+        component4(): number;
+        component5(): boolean;
+        component6(): boolean;
+        component7(): boolean;
+        copy(isEnableChat?: boolean, botIntelligenceLevel?: com.debertz.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: boolean, isEnablePreviewScreen?: boolean, botReplacesPlayerAfterTimeout?: boolean): com.debertz.logic.data.models.table.config.Options;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export namespace com.debertz.logic.data.models.table.config {
+    abstract class PlayersMode {
+        private constructor();
+        get players(): number;
+        static get TWO_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
+            get name(): "TWO_PLAYERS";
+            get ordinal(): 0;
+        };
+        static get THREE_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
+            get name(): "THREE_PLAYERS";
+            get ordinal(): 1;
+        };
+        static get FOUR_PLAYERS(): com.debertz.logic.data.models.table.config.PlayersMode & {
+            get name(): "FOUR_PLAYERS";
+            get ordinal(): 2;
+        };
+        static get FOUR_PLAYERS_BY_TEAM(): com.debertz.logic.data.models.table.config.PlayersMode & {
+            get name(): "FOUR_PLAYERS_BY_TEAM";
+            get ordinal(): 3;
+        };
+        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;
+        };
+    }
+}
+export namespace com.debertz.logic.data.models.table.config {
+    abstract class PointsMode {
+        private constructor();
+        get points(): number;
+        static get SMALL(): com.debertz.logic.data.models.table.config.PointsMode & {
+            get name(): "SMALL";
+            get ordinal(): 0;
+        };
+        static get MEDIUM(): com.debertz.logic.data.models.table.config.PointsMode & {
+            get name(): "MEDIUM";
+            get ordinal(): 1;
+        };
+        static get BIG(): com.debertz.logic.data.models.table.config.PointsMode & {
+            get name(): "BIG";
+            get ordinal(): 2;
+        };
+        static get TEST(): com.debertz.logic.data.models.table.config.PointsMode & {
+            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;
+        static get Companion(): {
+            create(points: number): com.debertz.logic.data.models.table.config.PointsMode;
+        };
+    }
+}
+export namespace com.debertz.logic.redux.actions {
+    const ClearAction: {
+        toString(): string;
+        get actionTag(): string;
+        notValidateWhenFinishing(): boolean;
+        notValidateWhenFinished(): boolean;
+    } & com.logic.domain.engine.definitions.Action & com.debertz.logic.redux.middlewares.validation.NotValidateIfGameFinishing & com.debertz.logic.redux.middlewares.validation.NotValidateIfGameFinished;
+}
+export namespace com.debertz.logic.redux.actions.client.from {
+    abstract class FromClientAction implements com.logic.domain.engine.definitions.Action {
+        protected constructor();
+        abstract get playerId(): string;
+        get actionTag(): string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export namespace com.debertz.logic.redux.actions.client.to {
+    abstract class ToClientAction implements com.logic.domain.engine.definitions.Action {
+        protected constructor();
+        abstract get sendToPlayerId(): string;
+        abstract get roomId(): Nullable<string>;
+        get actionTag(): string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export namespace com.debertz.logic.redux.actions.game {
+    abstract class GameAction implements com.logic.domain.engine.definitions.Action {
+        protected constructor();
+        get actionTag(): string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+    class PartyStartedAction extends com.debertz.logic.redux.actions.game.GameAction {
+        constructor(roomId: string, players: Array<string>, isFirstParty: boolean);
+        get roomId(): string;
+        get players(): Array<string>;
+        get isFirstParty(): boolean;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        component1(): string;
+        component2(): Array<string>;
+        component3(): boolean;
+        copy(roomId?: string, players?: Array<string>, isFirstParty?: boolean): com.debertz.logic.redux.actions.game.PartyStartedAction;
+        toString(): string;
+        get actionTag(): string;
+    }
+    class PartyEndedAction extends com.debertz.logic.redux.actions.game.GameAction {
+        constructor(roomId: string, earnedBiggestPointPlayerId: string, partyLosers: Array<string>, partyWinners: Array<string>, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>);
+        get roomId(): string;
+        get earnedBiggestPointPlayerId(): string;
+        get partyLosers(): Array<string>;
+        get partyWinners(): Array<string>;
+        get gameLosers(): Nullable<Array<string>>;
+        get gameWinners(): Nullable<Array<string>>;
+        get isGameFinished(): boolean;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        component1(): string;
+        component2(): string;
+        component3(): Array<string>;
+        component4(): Array<string>;
+        component5(): Nullable<Array<string>>;
+        component6(): Nullable<Array<string>>;
+        copy(roomId?: string, 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;
+        get actionTag(): string;
+    }
+}
+export namespace com.debertz.logic.redux.actions.mechanic {
+    abstract class MechanicAction implements com.logic.redux.actions.BufferedAction {
+        protected constructor();
+        ignoreBuffer(): boolean;
+        get actionTag(): string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+    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;
+        component1(): com.logic.data.models.TerminationGameReason;
+        copy(reason?: com.logic.data.models.TerminationGameReason): com.debertz.logic.redux.actions.mechanic.FinishingGameMechanicAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        ignoreBuffer(): boolean;
+        get actionTag(): string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+    interface NavigationMechanicAction extends com.logic.domain.engine.definitions.Action {
+        readonly sceneId: string;
+        readonly actId: Nullable<string>;
+        readonly actPayload: Nullable<com.debertz.logic.data.models.scenes.ActData>;
+        readonly actionTag: string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+    class SceneMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.actions.mechanic.NavigationMechanicAction, com.logic.redux.actions.ReleaseBufferTriggerAction, com.debertz.logic.redux.middlewares.validation.NotValidateIfGameFinishing, com.debertz.logic.redux.middlewares.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>;
+        get scenePayload(): Nullable<com.debertz.logic.data.models.scenes.SceneData>;
+        get actPayload(): Nullable<com.debertz.logic.data.models.scenes.ActData>;
+        notValidateWhenFinished(): boolean;
+        notValidateWhenFinishing(): boolean;
+        component1(): string;
+        component2(): Nullable<string>;
+        component3(): Nullable<com.debertz.logic.data.models.scenes.SceneData>;
+        component4(): Nullable<com.debertz.logic.data.models.scenes.ActData>;
+        copy(sceneId?: string, actId?: Nullable<string>, scenePayload?: Nullable<com.debertz.logic.data.models.scenes.SceneData>, actPayload?: Nullable<com.debertz.logic.data.models.scenes.ActData>): com.debertz.logic.redux.actions.mechanic.SceneMechanicAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        ignoreBuffer(): boolean;
+        get actionTag(): string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+    interface TerminatedAction extends com.logic.redux.actions.BufferedAction {
+        ignoreBuffer(): boolean;
+        readonly actionTag: string;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+    class PlayerConnectionChangedMechanicAction extends com.debertz.logic.redux.actions.mechanic.MechanicAction implements com.debertz.logic.redux.middlewares.validation.NotValidateIfGameFinishing, com.debertz.logic.redux.middlewares.validation.NotValidateIfGameFinished {
+        constructor(playerId: string, state: com.logic.data.models.player.PlayerConnectionState, isNoneActivePlayers: boolean);
+        get playerId(): string;
+        get state(): com.logic.data.models.player.PlayerConnectionState;
+        get isNoneActivePlayers(): boolean;
+        get isLive(): boolean;
+        get isTimeOut(): boolean;
+        get isLostConnection(): boolean;
+        get isLeft(): boolean;
+        get isDeleted(): boolean;
+        get shouldNotifyPlayers(): boolean;
+        component1(): string;
+        component2(): com.logic.data.models.player.PlayerConnectionState;
+        component3(): boolean;
+        copy(playerId?: string, state?: com.logic.data.models.player.PlayerConnectionState, isNoneActivePlayers?: boolean): com.debertz.logic.redux.actions.mechanic.PlayerConnectionChangedMechanicAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        ignoreBuffer(): boolean;
+        get actionTag(): string;
+        notValidateWhenFinishing(): boolean;
+        notValidateWhenFinished(): boolean;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export namespace com.debertz.logic.redux.middlewares.validation {
+    interface NotValidateIfGameFinishing {
+        notValidateWhenFinishing(): boolean;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+    interface NotValidateIfGameFinished {
+        notValidateWhenFinished(): boolean;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export const ERROR: string;
+export const DEBUG: string;
+export const WARN: string;
+export 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;
+        error(error: Nullable<com.debertz.logic.client.redux.state.ErrorState>): void;
+        readonly __doNotUseIt: __doNotImplementIt;
+    }
+}
+export 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);
+        get message(): Nullable<string>;
+        get userInfo(): Nullable<com.logic.data.models.player.GameUserInfo>;
+        get reason(): com.logic.data.models.TerminationGameReason;
+        component1(): Nullable<string>;
+        component2(): Nullable<com.logic.data.models.player.GameUserInfo>;
+        component3(): 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 interface GameClientEngineController {
+    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): com.debertz.logic.client.domain.mechanic.online.OnlineGameMechanic;
+    readonly __doNotUseIt: __doNotImplementIt;
+}
+export function createGameClientController(loggerCallback: (p0: string, p1: Nullable<string>, p2: string, p3: Nullable<Error>, p4: Nullable<com.logic.utils.logger.game.LoggerPayload>) => void): GameClientEngineController;
+export as namespace Logic_Debertz_game_client_logic_deb;