raspberry_games_engine_helpers 1.8.248

package/Logic_Debertz-engine.d.ts

@@ -0,0 +1,1844 @@
+type Nullable<T> = T | null | undefined
+export declare namespace kotlin.collections {
+    interface KtList<E> /* extends kotlin.collections.Collection<E> */ {
+        asJsReadonlyArrayView(): ReadonlyArray<E>;
+        readonly __doNotUseOrImplementIt: {
+            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 {
+        enabled: boolean;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.raspberry.logger.LoggerEnabledTrigger": unique symbol;
+        } & games.raspberry.logger.RaspberryLogger["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.raspberry.logger {
+    interface LoggerPayload {
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.raspberry.logger.LoggerPayload": unique symbol;
+        };
+    }
+}
+export declare namespace games.raspberry.logger {
+    interface RaspberryLogger extends games.raspberry.logger.output.LoggerOutput {
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.raspberry.logger.RaspberryLogger": unique symbol;
+        } & games.raspberry.logger.output.LoggerOutput["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.raspberry.logger.output {
+    interface LoggerOutput {
+        d(tag: Nullable<string> | undefined, message: string, payload?: Nullable<any>): void;
+        e(tag?: Nullable<string>, message?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
+        w(tag?: Nullable<string>, message?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
+        v(tag?: Nullable<string>, message?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
+        i(tag: Nullable<string> | undefined, message: string, payload?: Nullable<any>): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.raspberry.logger.output.LoggerOutput": unique symbol;
+        };
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class CardDecksRequestUserData {
+        constructor(id: string, count: number);
+        get id(): string;
+        get count(): number;
+        copy(id?: string, count?: number): games.raspberry.card_game.random.data.models.CardDecksRequestUserData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    class CardDeckRequestUserData {
+        constructor(players: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.UserInfoData>, gameId: string);
+        get players(): kotlin.collections.KtList<games.raspberry.card_game.random.data.models.UserInfoData>;
+        get gameId(): string;
+        copy(players?: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.UserInfoData>, gameId?: string): games.raspberry.card_game.random.data.models.CardDeckRequestUserData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    class UserInfoData {
+        constructor(id: string, name: string);
+        get id(): string;
+        get name(): string;
+        copy(id?: string, name?: string): games.raspberry.card_game.random.data.models.UserInfoData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class GameCardDecksRecord {
+        constructor(poolId: string, signature: Nullable<string>, userData: games.raspberry.card_game.random.data.models.CardDeckRequestUserData, rounds?: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.GameCardDeckData>);
+        get poolId(): string;
+        get signature(): Nullable<string>;
+        get userData(): games.raspberry.card_game.random.data.models.CardDeckRequestUserData;
+        get rounds(): kotlin.collections.KtList<games.raspberry.card_game.random.data.models.GameCardDeckData>;
+        copy(poolId?: string, signature?: Nullable<string>, userData?: games.raspberry.card_game.random.data.models.CardDeckRequestUserData, rounds?: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.GameCardDeckData>): games.raspberry.card_game.random.data.models.GameCardDecksRecord;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            firstRound(poolId: string, signature: Nullable<string>, newCardDeckData: games.raspberry.card_game.random.data.models.GameCardDeckData, userData: games.raspberry.card_game.random.data.models.CardDeckRequestUserData): games.raspberry.card_game.random.data.models.GameCardDecksRecord;
+            newRound(gameCardDecksRecord: games.raspberry.card_game.random.data.models.GameCardDecksRecord, newCardDeckData: games.raspberry.card_game.random.data.models.GameCardDeckData): games.raspberry.card_game.random.data.models.GameCardDecksRecord;
+        };
+    }
+    class GameCardDeckData {
+        constructor(cardDeckIndex: number, cards: kotlin.collections.KtList<number>);
+        get cardDeckIndex(): number;
+        get cards(): kotlin.collections.KtList<number>;
+        copy(cardDeckIndex?: number, cards?: kotlin.collections.KtList<number>): games.raspberry.card_game.random.data.models.GameCardDeckData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class HttpConfig {
+        constructor(baseUrl: string, timeoutMillis?: number);
+        get baseUrl(): string;
+        get timeoutMillis(): number;
+        copy(baseUrl?: string, timeoutMillis?: number): games.raspberry.card_game.random.data.models.HttpConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.raspberry.card_game.random.data.models {
+    class RandomOrgConfig {
+        constructor(apiKey?: string, poolSize?: number, thresholdForUsedPool?: number, httpConfig?: games.raspberry.card_game.random.data.models.HttpConfig);
+        get apiKey(): string;
+        get poolSize(): number;
+        get thresholdForUsedPool(): number;
+        get httpConfig(): games.raspberry.card_game.random.data.models.HttpConfig;
+        copy(apiKey?: string, poolSize?: number, thresholdForUsedPool?: number, httpConfig?: games.raspberry.card_game.random.data.models.HttpConfig): games.raspberry.card_game.random.data.models.RandomOrgConfig;
+        toString(): string;
+        hashCode(): number;
+        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;
+    };
+}
+export declare namespace com.logic {
+    const GameEngineConfig: {
+        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;
+        get requireDirectoryPath(): 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;
+        static get Companion(): {
+            getClientEngineTestMode(fileLogsEnabled: boolean, logsDirectoryPath: string, fileNameFormat?: string): com.logic.data.models.CoreConfig;
+            formatter(segment: string, gameId: string, roomId: string, userId: string): string;
+        };
+    }
+}
+export declare namespace com.logic.data.models {
+    abstract class TerminationGameReason {
+        protected constructor();
+    }
+    class PlayerLostConnectionReason extends com.logic.data.models.TerminationGameReason implements com.logic.data.models.FinishPlayerReason {
+        constructor(playerId: string, tag: Nullable<string>);
+        get playerId(): string;
+        get tag(): Nullable<string>;
+        get connectionState(): com.logic.data.models.player.PlayerConnectionState;
+        copy(playerId?: string, tag?: Nullable<string>): com.logic.data.models.PlayerLostConnectionReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.FinishPlayerReason["__doNotUseOrImplementIt"];
+    }
+    class PlayerTimeoutReason extends com.logic.data.models.TerminationGameReason implements com.logic.data.models.FinishPlayerReason {
+        constructor(playerId: string, tag: Nullable<string>);
+        get playerId(): string;
+        get tag(): Nullable<string>;
+        get connectionState(): com.logic.data.models.player.PlayerConnectionState;
+        copy(playerId?: string, tag?: Nullable<string>): com.logic.data.models.PlayerTimeoutReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.FinishPlayerReason["__doNotUseOrImplementIt"];
+    }
+    class PlayerExitReason extends com.logic.data.models.TerminationGameReason implements com.logic.data.models.FinishPlayerReason {
+        constructor(playerId: string);
+        get playerId(): string;
+        get connectionState(): com.logic.data.models.player.PlayerConnectionState;
+        copy(playerId?: string): com.logic.data.models.PlayerExitReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.FinishPlayerReason["__doNotUseOrImplementIt"];
+    }
+    interface FinishPlayerReason {
+        readonly playerId: string;
+        readonly connectionState: com.logic.data.models.player.PlayerConnectionState;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.data.models.FinishPlayerReason": unique symbol;
+        };
+    }
+    class GameFinishedReason extends com.logic.data.models.TerminationGameReason {
+        constructor(reason: com.logic.data.models.GameFinishedReason.Reason);
+        get reason(): com.logic.data.models.GameFinishedReason.Reason;
+        copy(reason?: com.logic.data.models.GameFinishedReason.Reason): com.logic.data.models.GameFinishedReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    namespace GameFinishedReason {
+        abstract class Reason {
+            private constructor();
+            static get DEPLOY(): com.logic.data.models.GameFinishedReason.Reason & {
+                get name(): "DEPLOY";
+                get ordinal(): 0;
+            };
+            static get PLAYER_DELETED(): com.logic.data.models.GameFinishedReason.Reason & {
+                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(): 3;
+            };
+            static get GAME_NOT_EXISTS(): com.logic.data.models.GameFinishedReason.Reason & {
+                get name(): "GAME_NOT_EXISTS";
+                get ordinal(): 4;
+            };
+            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(): {
+            } & any/* kotlinx.serialization.internal.SerializerFactory */;
+        }
+    }
+    class GameErrorReason extends com.logic.data.models.TerminationGameReason {
+        constructor(reason: com.logic.data.models.GameErrorReason.Reason);
+        get reason(): com.logic.data.models.GameErrorReason.Reason;
+        copy(reason?: com.logic.data.models.GameErrorReason.Reason): com.logic.data.models.GameErrorReason;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    namespace GameErrorReason {
+        abstract class Reason {
+            private constructor();
+            static get SERVER_ERROR(): com.logic.data.models.GameErrorReason.Reason & {
+                get name(): "SERVER_ERROR";
+                get ordinal(): 0;
+            };
+            static get INTERNAL_ERROR(): com.logic.data.models.GameErrorReason.Reason & {
+                get name(): "INTERNAL_ERROR";
+                get ordinal(): 1;
+            };
+            static get GAME_NOT_EXISTS(): com.logic.data.models.GameErrorReason.Reason & {
+                get name(): "GAME_NOT_EXISTS";
+                get ordinal(): 2;
+            };
+            static get WRONG_PLAYER_TURN(): com.logic.data.models.GameErrorReason.Reason & {
+                get name(): "WRONG_PLAYER_TURN";
+                get ordinal(): 3;
+            };
+            static get PLAYER_DISCONNECTED(): com.logic.data.models.GameErrorReason.Reason & {
+                get name(): "PLAYER_DISCONNECTED";
+                get ordinal(): 4;
+            };
+            get name(): "SERVER_ERROR" | "INTERNAL_ERROR" | "GAME_NOT_EXISTS" | "WRONG_PLAYER_TURN" | "PLAYER_DISCONNECTED";
+            get ordinal(): 0 | 1 | 2 | 3 | 4;
+            static values(): Array<com.logic.data.models.GameErrorReason.Reason>;
+            static valueOf(value: string): com.logic.data.models.GameErrorReason.Reason;
+            static get Companion(): {
+            } & any/* kotlinx.serialization.internal.SerializerFactory */;
+        }
+    }
+    const WaitingForConnectionReason: {
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & com.logic.data.models.TerminationGameReason;
+    const ProcessingReason: {
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & com.logic.data.models.TerminationGameReason;
+}
+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, 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>;
+        toString(): string;
+        copy(playerId?: string, name?: string, avatarUrl?: Nullable<string>, isBot?: boolean, initialLuckyFactor?: Nullable<number>, payload?: Nullable<any>): com.logic.data.models.player.GameUserInfo;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace com.logic.data.models.player {
+    interface PlayerIdContract {
+        readonly playerId: string;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.data.models.player.PlayerIdContract": unique symbol;
+        };
+    }
+    function getPlayer<T extends com.logic.data.models.player.PlayerIdContract>(_this_: kotlin.collections.KtList<T>, id: string): T;
+    function getPlayerIndex<T extends com.logic.data.models.player.PlayerIdContract>(_this_: kotlin.collections.KtList<T>, playerId: string): number;
+}
+export declare 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 name(): "LIVE" | "TIMEOUT" | "LOST_CONNECTION" | "LEFT" | "DISCONNECTING" | "DELETED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        get isLive(): boolean;
+        get isTimeOut(): boolean;
+        get isLostConnection(): boolean;
+        get isLeft(): boolean;
+        get isDeleted(): boolean;
+        get isDisconnecting(): boolean;
+        get isNotAlive(): boolean;
+        get isDisconnected(): boolean;
+        get isClientDisconnectReason(): boolean;
+        get isServerDisconnectReason(): boolean;
+        static values(): Array<com.logic.data.models.player.PlayerConnectionState>;
+        static valueOf(value: string): com.logic.data.models.player.PlayerConnectionState;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace com.logic.redux.actions {
+    interface BufferedAction extends com.logic.redux.store.definitions.Action {
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.redux.actions.BufferedAction": unique symbol;
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
+    }
+    interface IgnoreBufferForAction extends com.logic.redux.store.definitions.Action {
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.redux.actions.IgnoreBufferForAction": unique symbol;
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
+    }
+    interface ReleaseBufferTriggerAction extends com.logic.redux.store.definitions.Action {
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.redux.actions.ReleaseBufferTriggerAction": unique symbol;
+        } & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace com.logic.redux.actions.validation {
+    interface NotValidateIfGameFinished {
+        notValidateWhenFinished(): boolean;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.redux.actions.validation.NotValidateIfGameFinished": unique symbol;
+        };
+    }
+}
+export declare namespace com.logic.redux.actions.validation {
+    interface NotValidateIfGameFinishing {
+        notValidateWhenFinishing(): boolean;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.redux.actions.validation.NotValidateIfGameFinishing": unique symbol;
+        };
+    }
+}
+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.outputs {
+    abstract class LogType {
+        private constructor();
+        static get DEBUG(): com.logic.utils.logger.outputs.LogType & {
+            get name(): "DEBUG";
+            get ordinal(): 0;
+        };
+        static get ERROR(): com.logic.utils.logger.outputs.LogType & {
+            get name(): "ERROR";
+            get ordinal(): 1;
+        };
+        static get WARN(): com.logic.utils.logger.outputs.LogType & {
+            get name(): "WARN";
+            get ordinal(): 2;
+        };
+        static get VERBOSE(): com.logic.utils.logger.outputs.LogType & {
+            get name(): "VERBOSE";
+            get ordinal(): 3;
+        };
+        static get INFO(): com.logic.utils.logger.outputs.LogType & {
+            get name(): "INFO";
+            get ordinal(): 4;
+        };
+        get name(): "DEBUG" | "ERROR" | "WARN" | "VERBOSE" | "INFO";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
+        static values(): Array<com.logic.utils.logger.outputs.LogType>;
+        static valueOf(value: string): com.logic.utils.logger.outputs.LogType;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace com.logic.utils.logger.outputs {
+    interface ObservableLoggerOutput extends games.raspberry.logger.output.LoggerOutput, games.raspberry.logger.LoggerEnabledTrigger {
+        payloadToKeyMapper: (p0: Nullable<any>) => Nullable<string>;
+        observe(types?: Array<com.logic.utils.logger.outputs.LogType>): any/* kotlinx.coroutines.flow.Flow<com.logic.utils.logger.outputs.LoggerOutputDataDto> */;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.utils.logger.outputs.ObservableLoggerOutput": unique symbol;
+        } & games.raspberry.logger.output.LoggerOutput["__doNotUseOrImplementIt"] & games.raspberry.logger.LoggerEnabledTrigger["__doNotUseOrImplementIt"];
+    }
+    class LoggerOutputDataDto {
+        constructor(type: com.logic.utils.logger.outputs.LogType, key: Nullable<string>, tag: Nullable<string>, message: Nullable<string>, stackTrace: Nullable<string>);
+        get type(): com.logic.utils.logger.outputs.LogType;
+        get key(): Nullable<string>;
+        get tag(): Nullable<string>;
+        get message(): Nullable<string>;
+        get stackTrace(): Nullable<string>;
+        toMessageLog(): string;
+        copy(type?: com.logic.utils.logger.outputs.LogType, key?: Nullable<string>, tag?: Nullable<string>, message?: Nullable<string>, stackTrace?: Nullable<string>): com.logic.utils.logger.outputs.LoggerOutputDataDto;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+        };
+    }
+}
+export declare namespace games.jass.logic {
+    interface GameStoreContract {
+        readonly id: string;
+        readonly table: games.jass.logic.data.models.table.JassTable;
+        readonly isTableExists: boolean;
+        readonly gameLifecycleState: games.jass.logic.data.models.GameLifecycleState;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.jass.logic.GameStoreContract": unique symbol;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models {
+    class DealerConfig {
+        constructor(dealerStrategy?: games.jass.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean, cards?: Nullable<Array<number>>);
+        get dealerStrategy(): games.jass.logic.domain.interactors.dealer.DealerStrategy;
+        get isBotsAreHappy(): boolean;
+        get cards(): Nullable<Array<number>>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(dealerStrategy?: games.jass.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean, cards?: Nullable<Array<number>>): games.jass.logic.data.models.DealerConfig;
+        toString(): string;
+        static get Companion(): {
+            getFromServerConfig(dealerStrategy?: string, cardsJson?: Nullable<string>): games.jass.logic.data.models.DealerConfig;
+            fake(cards?: Array<number>): games.jass.logic.data.models.DealerConfig;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models {
+    class EngineBotConfig {
+        constructor(botExitsWhenNGameNumberIsFinished?: Nullable<number>, autoStepLastCard?: boolean, simulateBotThinkingDelay?: boolean, isDelayForBot?: boolean);
+        get botExitsWhenNGameNumberIsFinished(): Nullable<number>;
+        get autoStepLastCard(): boolean;
+        get simulateBotThinkingDelay(): boolean;
+        get isDelayForBot(): boolean;
+        copy(botExitsWhenNGameNumberIsFinished?: Nullable<number>, autoStepLastCard?: boolean, simulateBotThinkingDelay?: boolean, isDelayForBot?: boolean): games.jass.logic.data.models.EngineBotConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models {
+    class EngineLogicConfig {
+        constructor(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, gameHistoryAnalytics?: boolean, updateRating?: boolean, validateFromClientActionTags?: boolean, validateIfMainThread?: boolean, playerTimeoutFactorToFinishStep?: number, openRoomIfFinished?: boolean, minPlayersToOpenRoom?: number);
+        get supportBackwardActions(): boolean;
+        get validateTestMode(): boolean;
+        get verboseGameHistory(): boolean;
+        get gameHistoryMetadata(): boolean;
+        get updateRating(): boolean;
+        get validateFromClientActionTags(): boolean;
+        get validateIfMainThread(): boolean;
+        get playerTimeoutFactorToFinishStep(): number;
+        get openRoomIfFinished(): boolean;
+        get minPlayersToOpenRoom(): number;
+        copy(supportBackwardActions?: boolean, validateTestMode?: boolean, verboseGameHistory?: boolean, gameHistoryAnalytics?: boolean, updateRating?: 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;
+        static get Companion(): {
+            getClientEngineTestMode(): games.jass.logic.data.models.EngineLogicConfig;
+            getServerEngineMode(isProduction: boolean, supportBackwardActions?: boolean, validateFromClientActionTags?: boolean, openRoomIfFinished?: boolean, updateRating?: boolean, playerTimeoutFactorToFinishStep?: number): games.jass.logic.data.models.EngineLogicConfig;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models {
+    abstract class GameLifecycleState {
+        private constructor();
+        static get CREATED(): games.jass.logic.data.models.GameLifecycleState & {
+            get name(): "CREATED";
+            get ordinal(): 0;
+        };
+        static get CREATING(): games.jass.logic.data.models.GameLifecycleState & {
+            get name(): "CREATING";
+            get ordinal(): 1;
+        };
+        static get FINISHING(): games.jass.logic.data.models.GameLifecycleState & {
+            get name(): "FINISHING";
+            get ordinal(): 2;
+        };
+        static get FINISHED(): games.jass.logic.data.models.GameLifecycleState & {
+            get name(): "FINISHED";
+            get ordinal(): 3;
+        };
+        get name(): "CREATED" | "CREATING" | "FINISHING" | "FINISHED";
+        get ordinal(): 0 | 1 | 2 | 3;
+        static values(): Array<games.jass.logic.data.models.GameLifecycleState>;
+        static valueOf(value: string): games.jass.logic.data.models.GameLifecycleState;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models {
+    class GameSessionAnalytics {
+        constructor(duration: any/* kotlin.time.Duration */, gamesCount: number, roundsCountTotal: number, handsCount: number, playerAnalytics: Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>);
+        get duration(): any/* kotlin.time.Duration */;
+        get gamesCount(): number;
+        get roundsCountTotal(): number;
+        get handsCount(): number;
+        get playerAnalytics(): Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>;
+        get allCombinationCounts(): Array<games.jass.logic.data.models.CombinationPair>;
+        get allCombinationsAnalytics(): games.jass.logic.data.models.player.analytics.CombinationsAnalytics;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        toString(): string;
+        copy(duration?: any/* kotlin.time.Duration */, gamesCount?: number, roundsCountTotal?: number, handsCount?: number, playerAnalytics?: Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>): games.jass.logic.data.models.GameSessionAnalytics;
+    }
+    class CombinationPair {
+        constructor(type: games.jass.logic.data.models.table.combinations.CombinationType, count: number);
+        get type(): games.jass.logic.data.models.table.combinations.CombinationType;
+        get count(): number;
+        copy(type?: games.jass.logic.data.models.table.combinations.CombinationType, count?: number): games.jass.logic.data.models.CombinationPair;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.config {
+    class ServerReduxConfig {
+        constructor(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsPeriod?: number);
+        get finishGameIfAllBots(): boolean;
+        get waitForPlayerToReconnect(): boolean;
+        get waitForPlayerToReconnectTimeOutMillis(): number;
+        get closeIfBotsAtFinish(): boolean;
+        get botReplacesPlayerAfterTimeout(): boolean;
+        get enabledCombinedEvents(): boolean;
+        get delayToAskBotMillis(): number;
+        get combinedEventsPeriod(): number;
+        copy(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsPeriod?: number): games.jass.logic.data.models.config.ServerReduxConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            get DELAY_TO_BUFFER_EVENTS_MILLIS(): number;
+            getServerEngineMode(finishGameIfAllBots: boolean, botReplacesPlayerAfterTimeout: boolean, closeIfBotsAtFinish: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number): games.jass.logic.data.models.config.ServerReduxConfig;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.dealer {
+    class RandomData {
+        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.leagues {
+    abstract class League {
+        private constructor();
+        static get BEGINNER(): games.jass.logic.data.models.leagues.League & {
+            get name(): "BEGINNER";
+            get ordinal(): 0;
+        };
+        static get ROOKIE(): games.jass.logic.data.models.leagues.League & {
+            get name(): "ROOKIE";
+            get ordinal(): 1;
+        };
+        static get ADVANCED(): games.jass.logic.data.models.leagues.League & {
+            get name(): "ADVANCED";
+            get ordinal(): 2;
+        };
+        static get MASTER(): games.jass.logic.data.models.leagues.League & {
+            get name(): "MASTER";
+            get ordinal(): 3;
+        };
+        get name(): "BEGINNER" | "ROOKIE" | "ADVANCED" | "MASTER";
+        get ordinal(): 0 | 1 | 2 | 3;
+        getMinRating(): number;
+        isEnabled(): boolean;
+        static values(): Array<games.jass.logic.data.models.leagues.League>;
+        static valueOf(value: string): games.jass.logic.data.models.leagues.League;
+    }
+}
+export declare namespace games.jass.logic.data.models.leagues {
+    class LeaguesConfig {
+        constructor(initialRating: number, leagues: kotlin.collections.KtMap<games.jass.logic.data.models.leagues.League, games.jass.logic.data.models.leagues.LeagueInfo>);
+        get initialRating(): number;
+        get leagues(): kotlin.collections.KtMap<games.jass.logic.data.models.leagues.League, games.jass.logic.data.models.leagues.LeagueInfo>;
+        getLeagueByRating(rating: number, config?: games.jass.logic.data.models.leagues.LeaguesConfig): games.jass.logic.data.models.leagues.League;
+        getLeagueInfoByRating(rating: number, config?: games.jass.logic.data.models.leagues.LeaguesConfig): any/* kotlin.Pair<games.jass.logic.data.models.leagues.League, games.jass.logic.data.models.leagues.LeagueInfo> */;
+        copy(initialRating?: number, leagues?: kotlin.collections.KtMap<games.jass.logic.data.models.leagues.League, games.jass.logic.data.models.leagues.LeagueInfo>): games.jass.logic.data.models.leagues.LeaguesConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            defaultConfig(): games.jass.logic.data.models.leagues.LeaguesConfig;
+        };
+    }
+    class LeagueInfo {
+        constructor(minRating: number, enabled: boolean);
+        get minRating(): number;
+        get enabled(): boolean;
+        copy(minRating?: number, enabled?: boolean): games.jass.logic.data.models.leagues.LeagueInfo;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.messages.combinatios {
+    abstract class CombinationReason /* implements kotlin.Comparable<games.jass.logic.data.models.messages.combinatios.CombinationReason> */ {
+        private constructor();
+        static get WIN_SINGLE_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_SINGLE_COMBINATION";
+            get ordinal(): 0;
+        };
+        static get WIN_HIGHER_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_HIGHER_COMBINATION";
+            get ordinal(): 1;
+        };
+        static get WIN_HIGHER_CARD_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_HIGHER_CARD_COMBINATION";
+            get ordinal(): 2;
+        };
+        static get WIN_TRUMP_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_TRUMP_COMBINATION";
+            get ordinal(): 3;
+        };
+        static get WIN_HIGHER_PLAYER_NUMBER_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_HIGHER_PLAYER_NUMBER_COMBINATION";
+            get ordinal(): 4;
+        };
+        static get WIN_PARTNER_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "WIN_PARTNER_COMBINATION";
+            get ordinal(): 5;
+        };
+        static get REJECTED_NOT_TRUMP_SEVEN_IN_ROW_COMBINATION(): games.jass.logic.data.models.messages.combinatios.CombinationReason & {
+            get name(): "REJECTED_NOT_TRUMP_SEVEN_IN_ROW_COMBINATION";
+            get ordinal(): 6;
+        };
+        get name(): "WIN_SINGLE_COMBINATION" | "WIN_HIGHER_COMBINATION" | "WIN_HIGHER_CARD_COMBINATION" | "WIN_TRUMP_COMBINATION" | "WIN_HIGHER_PLAYER_NUMBER_COMBINATION" | "WIN_PARTNER_COMBINATION" | "REJECTED_NOT_TRUMP_SEVEN_IN_ROW_COMBINATION";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        static values(): Array<games.jass.logic.data.models.messages.combinatios.CombinationReason>;
+        static valueOf(value: string): games.jass.logic.data.models.messages.combinatios.CombinationReason;
+    }
+}
+export declare namespace games.jass.logic.data.models.player {
+    class JassPlayerLite {
+        constructor(userInfo: com.logic.data.models.player.GameUserInfo, options: any/* games.jass.logic.data.models.player.options.PlayerOptions */, points: any/* games.jass.logic.data.models.player.points.PlayerPoints */);
+        get userInfo(): com.logic.data.models.player.GameUserInfo;
+        get options(): any/* games.jass.logic.data.models.player.options.PlayerOptions */;
+        get points(): any/* games.jass.logic.data.models.player.points.PlayerPoints */;
+        copy(userInfo?: com.logic.data.models.player.GameUserInfo, options?: any/* games.jass.logic.data.models.player.options.PlayerOptions */, points?: any/* games.jass.logic.data.models.player.points.PlayerPoints */): games.jass.logic.data.models.player.JassPlayerLite;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player {
+    class UserProfilePayload {
+        constructor(socketId?: Nullable<string>, rating?: Nullable<number>, playedGamesCount?: number);
+        get socketId(): Nullable<string>;
+        get rating(): Nullable<number>;
+        get playedGamesCount(): number;
+        copy(socketId?: Nullable<string>, rating?: Nullable<number>, playedGamesCount?: number): games.jass.logic.data.models.player.UserProfilePayload;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.achievements {
+    class Achievements {
+        constructor(oldRating: number, newRating: number);
+        get oldRating(): number;
+        get newRating(): number;
+        get isRatingUp(): boolean;
+        copy(oldRating?: number, newRating?: number): games.jass.logic.data.models.player.achievements.Achievements;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.achievements {
+    class PlayerAchievements implements com.logic.data.models.player.PlayerIdContract {
+        constructor(playerId: string, oldRating: number, newRating: number);
+        get playerId(): string;
+        get oldRating(): number;
+        get newRating(): number;
+        copy(playerId?: string, oldRating?: number, newRating?: number): games.jass.logic.data.models.player.achievements.PlayerAchievements;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.player.analytics {
+    class CombinationsAnalytics {
+        constructor(combinations: Array<games.jass.logic.data.models.player.analytics.CombinationAnalytics>);
+        get combinations(): Array<games.jass.logic.data.models.player.analytics.CombinationAnalytics>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(combinations?: Array<games.jass.logic.data.models.player.analytics.CombinationAnalytics>): games.jass.logic.data.models.player.analytics.CombinationsAnalytics;
+        toString(): string;
+    }
+    class CombinationAnalytics {
+        constructor(type: games.jass.logic.data.models.table.combinations.CombinationType, count: number, acceptedCounts: number);
+        get type(): games.jass.logic.data.models.table.combinations.CombinationType;
+        get count(): number;
+        get acceptedCounts(): number;
+        copy(type?: games.jass.logic.data.models.table.combinations.CombinationType, count?: number, acceptedCounts?: number): games.jass.logic.data.models.player.analytics.CombinationAnalytics;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.analytics {
+    class PlayerAnalytics implements com.logic.data.models.player.PlayerIdContract {
+        constructor(playerId: string, factor: number, wasLiveDuringGame: boolean, liveDurationPercentage: Nullable<number>, combinationRecords: kotlin.collections.KtList<games.jass.logic.data.models.player.hand.CombinationRecord>);
+        get playerId(): string;
+        get factor(): number;
+        get wasLiveDuringGame(): boolean;
+        get liveDurationPercentage(): Nullable<number>;
+        get combinationRecords(): kotlin.collections.KtList<games.jass.logic.data.models.player.hand.CombinationRecord>;
+        get combinationCounts(): kotlin.collections.KtMap<games.jass.logic.data.models.table.combinations.CombinationType, number>;
+        get combinationsAnalytics(): games.jass.logic.data.models.player.analytics.CombinationsAnalytics;
+        toString(): string;
+        copy(playerId?: string, factor?: number, wasLiveDuringGame?: boolean, liveDurationPercentage?: Nullable<number>, combinationRecords?: kotlin.collections.KtList<games.jass.logic.data.models.player.hand.CombinationRecord>): games.jass.logic.data.models.player.analytics.PlayerAnalytics;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.player.analytics {
+    class PlayerHistoryAnalytics implements com.logic.data.models.player.PlayerIdContract/*, games.jass.logic.data.models.table.history.PlayerHistoryItem */ {
+        constructor(playerId: string, liveDurationPercentage: Nullable<number>, combinations: Nullable<kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.CombinationAnalytics>>, achievements: Nullable<games.jass.logic.data.models.player.achievements.Achievements>);
+        get playerId(): string;
+        get liveDurationPercentage(): Nullable<number>;
+        get combinations(): Nullable<kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.CombinationAnalytics>>;
+        get achievements(): Nullable<games.jass.logic.data.models.player.achievements.Achievements>;
+        copy(playerId?: string, liveDurationPercentage?: Nullable<number>, combinations?: Nullable<kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.CombinationAnalytics>>, achievements?: Nullable<games.jass.logic.data.models.player.achievements.Achievements>): games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.player.bids {
+    abstract class BidType {
+        private constructor();
+        static get POINTS(): games.jass.logic.data.models.player.bids.BidType & {
+            get name(): "POINTS";
+            get ordinal(): 0;
+        };
+        static get CAPOT(): games.jass.logic.data.models.player.bids.BidType & {
+            get name(): "CAPOT";
+            get ordinal(): 1;
+        };
+        static get COINCHE(): games.jass.logic.data.models.player.bids.BidType & {
+            get name(): "COINCHE";
+            get ordinal(): 2;
+        };
+        static get GENERAL(): games.jass.logic.data.models.player.bids.BidType & {
+            get name(): "GENERAL";
+            get ordinal(): 3;
+        };
+        static get SURCOINCHE(): games.jass.logic.data.models.player.bids.BidType & {
+            get name(): "SURCOINCHE";
+            get ordinal(): 4;
+        };
+        get name(): "POINTS" | "CAPOT" | "COINCHE" | "GENERAL" | "SURCOINCHE";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
+        static values(): Array<games.jass.logic.data.models.player.bids.BidType>;
+        static valueOf(value: string): games.jass.logic.data.models.player.bids.BidType;
+        static get Companion(): {
+            get belotBalgarian(): Array<games.jass.logic.data.models.player.bids.BidType>;
+            get coinche(): Array<games.jass.logic.data.models.player.bids.BidType>;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.hand {
+    class CombinationRecord {
+        constructor(id: string, type: games.jass.logic.data.models.table.combinations.CombinationType, state: games.jass.logic.data.models.table.combinations.CombinationState, value: number);
+        get id(): string;
+        get type(): games.jass.logic.data.models.table.combinations.CombinationType;
+        get state(): games.jass.logic.data.models.table.combinations.CombinationState;
+        get value(): number;
+        get isAccepted(): boolean;
+        copy(id?: string, type?: games.jass.logic.data.models.table.combinations.CombinationType, state?: games.jass.logic.data.models.table.combinations.CombinationState, value?: number): games.jass.logic.data.models.player.hand.CombinationRecord;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.points {
+    abstract class PointsDistributeMode {
+        private constructor();
+        static get ALL(): games.jass.logic.data.models.player.points.PointsDistributeMode & {
+            get name(): "ALL";
+            get ordinal(): 0;
+        };
+        static get HIGHEST_PLAYER(): games.jass.logic.data.models.player.points.PointsDistributeMode & {
+            get name(): "HIGHEST_PLAYER";
+            get ordinal(): 1;
+        };
+        static get HIGHER_THEN_FAILED_PLAYER(): games.jass.logic.data.models.player.points.PointsDistributeMode & {
+            get name(): "HIGHER_THEN_FAILED_PLAYER";
+            get ordinal(): 2;
+        };
+        get name(): "ALL" | "HIGHEST_PLAYER" | "HIGHER_THEN_FAILED_PLAYER";
+        get ordinal(): 0 | 1 | 2;
+        static values(): Array<games.jass.logic.data.models.player.points.PointsDistributeMode>;
+        static valueOf(value: string): games.jass.logic.data.models.player.points.PointsDistributeMode;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.state {
+    abstract class RoundContractState {
+        private constructor();
+        static get FAILED(): games.jass.logic.data.models.player.state.RoundContractState & {
+            get name(): "FAILED";
+            get ordinal(): 0;
+        };
+        static get FULFILLED(): games.jass.logic.data.models.player.state.RoundContractState & {
+            get name(): "FULFILLED";
+            get ordinal(): 1;
+        };
+        static get CONTROVERSIAL(): games.jass.logic.data.models.player.state.RoundContractState & {
+            get name(): "CONTROVERSIAL";
+            get ordinal(): 2;
+        };
+        get name(): "FAILED" | "FULFILLED" | "CONTROVERSIAL";
+        get ordinal(): 0 | 1 | 2;
+        get isFailed(): boolean;
+        get isFulfilled(): boolean;
+        get isControversial(): boolean;
+        static values(): Array<games.jass.logic.data.models.player.state.RoundContractState>;
+        static valueOf(value: string): games.jass.logic.data.models.player.state.RoundContractState;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.player.state {
+    abstract class RoundContractType {
+        private constructor();
+        static get TRUMP_TAKEN(): games.jass.logic.data.models.player.state.RoundContractType & {
+            get name(): "TRUMP_TAKEN";
+            get ordinal(): 0;
+        };
+        static get TRUMP_SELECTED(): games.jass.logic.data.models.player.state.RoundContractType & {
+            get name(): "TRUMP_SELECTED";
+            get ordinal(): 1;
+        };
+        static get NO_TRUMPS(): games.jass.logic.data.models.player.state.RoundContractType & {
+            get name(): "NO_TRUMPS";
+            get ordinal(): 2;
+        };
+        static get ALL_TRUMPS(): games.jass.logic.data.models.player.state.RoundContractType & {
+            get name(): "ALL_TRUMPS";
+            get ordinal(): 3;
+        };
+        get name(): "TRUMP_TAKEN" | "TRUMP_SELECTED" | "NO_TRUMPS" | "ALL_TRUMPS";
+        get ordinal(): 0 | 1 | 2 | 3;
+        static values(): Array<games.jass.logic.data.models.player.state.RoundContractType>;
+        static valueOf(value: string): games.jass.logic.data.models.player.state.RoundContractType;
+        static get Companion(): {
+            get debertzContractTypes(): kotlin.collections.KtList<games.jass.logic.data.models.player.state.RoundContractType>;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.rules {
+    class Rules {
+        constructor(needToPutHigherTrump: boolean, playerWhoChooseSuitGoFirst: boolean, winnerShuffleCards: boolean, playWithoutLiabilities: boolean, trumpCardGoToPlayerWhoShuffleCards: boolean, dealerInitialCardsCount: number, dealerFinalCardsCount: number, dealerCounterClockwise: boolean, contractTypes: Array<games.jass.logic.data.models.player.state.RoundContractType>, bidTypes: Array<games.jass.logic.data.models.player.bids.BidType>, combinationsWithFirstCard: Array<games.jass.logic.data.models.table.combinations.CombinationType>, protectBella: boolean, oneTryToProtectBella: boolean, enableFourSevensCombination: boolean, enableTrumpSevenCombination: boolean, enableTrumpSevenCombinationAfterDistribution: boolean, checkTrumpCombination: boolean, checkOnlyTrumpDebertz: boolean, distributePoints: boolean, pointsDistributeMode: games.jass.logic.data.models.player.points.PointsDistributeMode, enableFineAfterThirdFailedContract: boolean, fineAfterThirdFailedContract: number, enableFineIfNoBribes: boolean, fineIfNoBribes: number);
+        get needToPutHigherTrump(): boolean;
+        get playerWhoChooseSuitGoFirst(): boolean;
+        get winnerShuffleCards(): boolean;
+        get playWithoutLiabilities(): boolean;
+        get trumpCardGoToPlayerWhoShuffleCards(): boolean;
+        get dealerInitialCardsCount(): number;
+        get dealerFinalCardsCount(): number;
+        get dealerCounterClockwise(): boolean;
+        get contractTypes(): Array<games.jass.logic.data.models.player.state.RoundContractType>;
+        get bidTypes(): Array<games.jass.logic.data.models.player.bids.BidType>;
+        get combinationsWithFirstCard(): Array<games.jass.logic.data.models.table.combinations.CombinationType>;
+        get protectBella(): boolean;
+        get oneTryToProtectBella(): boolean;
+        get enableFourSevensCombination(): boolean;
+        get enableTrumpSevenCombination(): boolean;
+        get enableTrumpSevenCombinationAfterDistribution(): boolean;
+        get checkTrumpCombination(): boolean;
+        get checkOnlyTrumpDebertz(): boolean;
+        /** @deprecated use [pointsDistributeMode] */
+        get distributePoints(): boolean;
+        get pointsDistributeMode(): games.jass.logic.data.models.player.points.PointsDistributeMode;
+        get enableFineAfterThirdByte(): boolean;
+        get fineAfterThirdFailedContract(): number;
+        get enableFineIfNoBribes(): boolean;
+        get fineIfNoBribes(): number;
+        toString(): string;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(needToPutHigherTrump?: boolean, playerWhoChooseSuitGoFirst?: boolean, winnerShuffleCards?: boolean, playWithoutLiabilities?: boolean, trumpCardGoToPlayerWhoShuffleCards?: boolean, dealerInitialCardsCount?: number, dealerFinalCardsCount?: number, dealerCounterClockwise?: boolean, contractTypes?: Array<games.jass.logic.data.models.player.state.RoundContractType>, bidTypes?: Array<games.jass.logic.data.models.player.bids.BidType>, combinationsWithFirstCard?: Array<games.jass.logic.data.models.table.combinations.CombinationType>, protectBella?: boolean, oneTryToProtectBella?: boolean, enableFourSevensCombination?: boolean, enableTrumpSevenCombination?: boolean, enableTrumpSevenCombinationAfterDistribution?: boolean, checkTrumpCombination?: boolean, checkOnlyTrumpDebertz?: boolean, distributePoints?: boolean, pointsDistributeMode?: games.jass.logic.data.models.player.points.PointsDistributeMode, enableFineAfterThirdFailedContract?: boolean, fineAfterThirdFailedContract?: number, enableFineIfNoBribes?: boolean, fineIfNoBribes?: number): games.jass.logic.data.models.rules.Rules;
+        static get Companion(): {
+            get HAND_CARDS_INITIAL(): number;
+            get HAND_CARDS_FINAL(): number;
+            kharkiv(): games.jass.logic.data.models.rules.Rules;
+            saltivka(): games.jass.logic.data.models.rules.Rules;
+            klabor(): games.jass.logic.data.models.rules.Rules;
+            belotBulgarian(): games.jass.logic.data.models.rules.Rules;
+            debertzCommon(): games.jass.logic.data.models.rules.Rules;
+            belot(): games.jass.logic.data.models.rules.Rules;
+            custom(): games.jass.logic.data.models.rules.Rules;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.rules {
+    abstract class RulesSetType {
+        private constructor();
+        static get belot(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "belot";
+            get ordinal(): 0;
+        };
+        static get klabor(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "klabor";
+            get ordinal(): 1;
+        };
+        static get debertzCommon(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "debertzCommon";
+            get ordinal(): 2;
+        };
+        static get debertzKharkiv(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "debertzKharkiv";
+            get ordinal(): 3;
+        };
+        static get debertzSaltivka(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "debertzSaltivka";
+            get ordinal(): 4;
+        };
+        static get custom(): games.jass.logic.data.models.rules.RulesSetType & {
+            get name(): "custom";
+            get ordinal(): 5;
+        };
+        get name(): "belot" | "klabor" | "debertzCommon" | "debertzKharkiv" | "debertzSaltivka" | "custom";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        get value(): string;
+        getRules(): games.jass.logic.data.models.rules.Rules;
+        get isCustom(): boolean;
+        static values(): Array<games.jass.logic.data.models.rules.RulesSetType>;
+        static valueOf(value: string): games.jass.logic.data.models.rules.RulesSetType;
+    }
+}
+export declare namespace games.jass.logic.data.models.scenes {
+    interface ActData {
+        readonly actId: string;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.jass.logic.data.models.scenes.ActData": unique symbol;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.scenes {
+    interface SceneData {
+        readonly sceneId: string;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.jass.logic.data.models.scenes.SceneData": unique symbol;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.table {
+    class JassTable {
+        constructor(id: string, version: string, createdAt: any/* kotlinx.datetime.Instant */, config: games.jass.logic.data.models.table.config.Config, players: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.JassPlayer */>, spectators: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.Spectator */>, sceneInfo: any/* games.jass.logic.data.models.table.scene.SceneInfo */, cardsOnTable: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.table.bribes.CardOnTable */>, bribes: kotlin.collections.KtList<any/* games.jass.logic.data.models.table.cards.Bribe */>, cardDeck: Nullable<any>/* Nullable<games.jass.logic.data.models.table.cards.CardDeck> */, gameInfo: any/* games.jass.logic.data.models.table.GameInfo */, gameHistory: games.jass.logic.data.models.table.history.GameHistory);
+        get id(): string;
+        get version(): string;
+        get createdAt(): any/* kotlinx.datetime.Instant */;
+        get config(): games.jass.logic.data.models.table.config.Config;
+        get players(): kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.JassPlayer */>;
+        get spectators(): kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.Spectator */>;
+        get sceneInfo(): any/* games.jass.logic.data.models.table.scene.SceneInfo */;
+        get cardsOnTable(): kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.table.bribes.CardOnTable */>;
+        get bribes(): kotlin.collections.KtList<any/* games.jass.logic.data.models.table.cards.Bribe */>;
+        get cardDeck(): Nullable<any>/* Nullable<games.jass.logic.data.models.table.cards.CardDeck> */;
+        get gameInfo(): any/* games.jass.logic.data.models.table.GameInfo */;
+        get gameHistory(): games.jass.logic.data.models.table.history.GameHistory;
+        get gameId(): string;
+        get gameDuration(): any/* kotlin.time.Duration */;
+        get gameCreatedAt(): any/* kotlinx.datetime.Instant */;
+        get playersConnections(): kotlin.collections.KtList<any/* kotlin.Pair<string, com.logic.data.models.player.PlayerConnectionState> */>;
+        get users(): Array<com.logic.data.models.player.GameUserInfo>;
+        get isCardDeckExist(): boolean;
+        get requireCardDeck(): any/* games.jass.logic.data.models.table.cards.CardDeck */;
+        get currentTrump(): Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */;
+        get isGameFinished(): boolean;
+        toString(): string;
+        copy(id?: string, version?: string, createdAt?: any/* kotlinx.datetime.Instant */, config?: games.jass.logic.data.models.table.config.Config, players?: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.JassPlayer */>, spectators?: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.Spectator */>, sceneInfo?: any/* games.jass.logic.data.models.table.scene.SceneInfo */, cardsOnTable?: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.table.bribes.CardOnTable */>, bribes?: kotlin.collections.KtList<any/* games.jass.logic.data.models.table.cards.Bribe */>, cardDeck?: Nullable<any>/* Nullable<games.jass.logic.data.models.table.cards.CardDeck> */, gameInfo?: any/* games.jass.logic.data.models.table.GameInfo */, gameHistory?: games.jass.logic.data.models.table.history.GameHistory): games.jass.logic.data.models.table.JassTable;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            initial(tableId: string, gameId: string, version: string, config: games.jass.logic.data.models.table.config.Config, players: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.JassPlayer */>, spectators: kotlin.collections.KtList<com.logic.data.models.player.PlayerIdContract/* games.jass.logic.data.models.player.Spectator */>): games.jass.logic.data.models.table.JassTable;
+            restartRound(version: string, tableLite: games.jass.logic.data.models.table.JassTableLite): games.jass.logic.data.models.table.JassTable;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.table {
+    class JassTableLite {
+        constructor(id: string, config: games.jass.logic.data.models.table.config.ConfigLite, players: kotlin.collections.KtList<games.jass.logic.data.models.player.JassPlayerLite>, gameInfo: any/* games.jass.logic.data.models.table.GameInfo */);
+        get id(): string;
+        get config(): games.jass.logic.data.models.table.config.ConfigLite;
+        get players(): kotlin.collections.KtList<games.jass.logic.data.models.player.JassPlayerLite>;
+        get gameInfo(): any/* games.jass.logic.data.models.table.GameInfo */;
+        copy(id?: string, config?: games.jass.logic.data.models.table.config.ConfigLite, players?: kotlin.collections.KtList<games.jass.logic.data.models.player.JassPlayerLite>, gameInfo?: any/* games.jass.logic.data.models.table.GameInfo */): games.jass.logic.data.models.table.JassTableLite;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.table {
+    class TableLoggerPayload implements games.raspberry.logger.LoggerPayload {
+        constructor(id: string, gameId: string, players: Array<games.jass.logic.data.models.table.PlayerLoggerPayload>);
+        get id(): string;
+        get gameId(): string;
+        get players(): Array<games.jass.logic.data.models.table.PlayerLoggerPayload>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        toString(): string;
+        copy(id?: string, gameId?: string, players?: Array<games.jass.logic.data.models.table.PlayerLoggerPayload>): games.jass.logic.data.models.table.TableLoggerPayload;
+        readonly __doNotUseOrImplementIt: games.raspberry.logger.LoggerPayload["__doNotUseOrImplementIt"];
+    }
+    class PlayerLoggerPayload implements games.raspberry.logger.LoggerPayload {
+        constructor(playerId: string, connectionState: Nullable<com.logic.data.models.player.PlayerConnectionState>);
+        get playerId(): string;
+        get connectionState(): Nullable<com.logic.data.models.player.PlayerConnectionState>;
+        toString(): string;
+        copy(playerId?: string, connectionState?: Nullable<com.logic.data.models.player.PlayerConnectionState>): games.jass.logic.data.models.table.PlayerLoggerPayload;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        readonly __doNotUseOrImplementIt: games.raspberry.logger.LoggerPayload["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.table.combinations {
+    class Combination /* implements games.jass.logic.data.models.table.combinations.CombinationContract */ {
+        constructor(id: string, type: games.jass.logic.data.models.table.combinations.CombinationType, cards: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>, reasons: kotlin.collections.KtSet<games.jass.logic.data.models.messages.combinatios.CombinationReason>);
+        toString(): string;
+        copy(id?: string, type?: games.jass.logic.data.models.table.combinations.CombinationType, cards?: Nullable<kotlin.collections.KtList<any/* io.raspberryapps.card_game.core.data.models.cards.GameCard */>>, reasons?: kotlin.collections.KtSet<games.jass.logic.data.models.messages.combinatios.CombinationReason>): games.jass.logic.data.models.table.combinations.Combination;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.combinations {
+    abstract class CombinationState {
+        private constructor();
+        static get NOT_VERIFIED(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "NOT_VERIFIED";
+            get ordinal(): 0;
+        };
+        static get VERIFYING(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "VERIFYING";
+            get ordinal(): 1;
+        };
+        static get ACCEPTED(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "ACCEPTED";
+            get ordinal(): 2;
+        };
+        static get NOT_ACCEPTED(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "NOT_ACCEPTED";
+            get ordinal(): 3;
+        };
+        static get REJECTED(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "REJECTED";
+            get ordinal(): 4;
+        };
+        static get CANCELED(): games.jass.logic.data.models.table.combinations.CombinationState & {
+            get name(): "CANCELED";
+            get ordinal(): 5;
+        };
+        get name(): "NOT_VERIFIED" | "VERIFYING" | "ACCEPTED" | "NOT_ACCEPTED" | "REJECTED" | "CANCELED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        static values(): Array<games.jass.logic.data.models.table.combinations.CombinationState>;
+        static valueOf(value: string): games.jass.logic.data.models.table.combinations.CombinationState;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.combinations {
+    abstract class CombinationType {
+        private constructor();
+        static get BELA(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BELA";
+            get ordinal(): 0;
+        };
+        static get THREE_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "THREE_IN_ROW";
+            get ordinal(): 1;
+        };
+        static get FOUR_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_IN_ROW";
+            get ordinal(): 2;
+        };
+        static get FIVE_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FIVE_IN_ROW";
+            get ordinal(): 3;
+        };
+        static get SEVEN_IN_ROW(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "SEVEN_IN_ROW";
+            get ordinal(): 4;
+        };
+        static get SEVEN_TRUMP(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "SEVEN_TRUMP";
+            get ordinal(): 5;
+        };
+        static get FOUR_ACES(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_ACES";
+            get ordinal(): 6;
+        };
+        static get FOUR_KINGS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_KINGS";
+            get ordinal(): 7;
+        };
+        static get FOUR_DAMES(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_DAMES";
+            get ordinal(): 8;
+        };
+        static get FOUR_JACKS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_JACKS";
+            get ordinal(): 9;
+        };
+        static get FOUR_TENS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_TENS";
+            get ordinal(): 10;
+        };
+        static get FOUR_NINES(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_NINES";
+            get ordinal(): 11;
+        };
+        static get FOUR_SEVENS(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FOUR_SEVENS";
+            get ordinal(): 12;
+        };
+        static get FINE_NO_BRIBES(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FINE_NO_BRIBES";
+            get ordinal(): 13;
+        };
+        static get FINE_THIRD_FAILED_CONTRACT(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "FINE_THIRD_FAILED_CONTRACT";
+            get ordinal(): 14;
+        };
+        static get BONUS_LAST_BRIBE(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BONUS_LAST_BRIBE";
+            get ordinal(): 15;
+        };
+        static get BONUS_FAILED_CONTRACT(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BONUS_FAILED_CONTRACT";
+            get ordinal(): 16;
+        };
+        static get BONUS_CONTROVERSIAL_CONTRACT(): games.jass.logic.data.models.table.combinations.CombinationType & {
+            get name(): "BONUS_CONTROVERSIAL_CONTRACT";
+            get ordinal(): 17;
+        };
+        get name(): "BELA" | "THREE_IN_ROW" | "FOUR_IN_ROW" | "FIVE_IN_ROW" | "SEVEN_IN_ROW" | "SEVEN_TRUMP" | "FOUR_ACES" | "FOUR_KINGS" | "FOUR_DAMES" | "FOUR_JACKS" | "FOUR_TENS" | "FOUR_NINES" | "FOUR_SEVENS" | "FINE_NO_BRIBES" | "FINE_THIRD_FAILED_CONTRACT" | "BONUS_LAST_BRIBE" | "BONUS_FAILED_CONTRACT" | "BONUS_CONTROVERSIAL_CONTRACT";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17;
+        static values(): Array<games.jass.logic.data.models.table.combinations.CombinationType>;
+        static valueOf(value: string): games.jass.logic.data.models.table.combinations.CombinationType;
+        static get Companion(): {
+            get withFirstCardCombination(): kotlin.collections.KtList<games.jass.logic.data.models.table.combinations.CombinationType>;
+            get inRowCombinations(): kotlin.collections.KtList<games.jass.logic.data.models.table.combinations.CombinationType>;
+            get fourCardsCombinations(): kotlin.collections.KtList<games.jass.logic.data.models.table.combinations.CombinationType>;
+            get debertzWithFirstCardCombinations(): kotlin.collections.KtList<games.jass.logic.data.models.table.combinations.CombinationType>;
+            get belotWithFirstCardCombination(): kotlin.collections.KtList<games.jass.logic.data.models.table.combinations.CombinationType>;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.combinations {
+    class PlayerCombinations implements com.logic.data.models.player.PlayerIdContract {
+        constructor(playerId: string, combinations: Array<games.jass.logic.data.models.table.combinations.Combination>);
+        get playerId(): string;
+        get combinations(): Array<games.jass.logic.data.models.table.combinations.Combination>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(playerId?: string, combinations?: Array<games.jass.logic.data.models.table.combinations.Combination>): games.jass.logic.data.models.table.combinations.PlayerCombinations;
+        toString(): string;
+        readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.data.models.table.config {
+    abstract class BotIntelligenceLevel {
+        private constructor();
+        static get SUPER_HARD(): games.jass.logic.data.models.table.config.BotIntelligenceLevel & {
+            get name(): "SUPER_HARD";
+            get ordinal(): 0;
+        };
+        static get HARD(): games.jass.logic.data.models.table.config.BotIntelligenceLevel & {
+            get name(): "HARD";
+            get ordinal(): 1;
+        };
+        static get MEDIUM(): games.jass.logic.data.models.table.config.BotIntelligenceLevel & {
+            get name(): "MEDIUM";
+            get ordinal(): 2;
+        };
+        static get EASY(): games.jass.logic.data.models.table.config.BotIntelligenceLevel & {
+            get name(): "EASY";
+            get ordinal(): 3;
+        };
+        static get SUPER_EASY(): games.jass.logic.data.models.table.config.BotIntelligenceLevel & {
+            get name(): "SUPER_EASY";
+            get ordinal(): 4;
+        };
+        get name(): "SUPER_HARD" | "HARD" | "MEDIUM" | "EASY" | "SUPER_EASY";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
+        static values(): Array<games.jass.logic.data.models.table.config.BotIntelligenceLevel>;
+        static valueOf(value: string): games.jass.logic.data.models.table.config.BotIntelligenceLevel;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+    function getLevel(_this_: games.jass.logic.data.models.table.config.BotIntelligenceLevel): number;
+}
+export declare namespace games.jass.logic.data.models.table.config {
+    class Config {
+        constructor(rules: games.jass.logic.data.models.rules.Rules, rulesSetType: games.jass.logic.data.models.rules.RulesSetType, options: games.jass.logic.data.models.table.config.Options, playersMode: games.jass.logic.data.models.table.config.PlayersMode, pointsMode: games.jass.logic.data.models.table.config.PointsMode, timeoutTimeMillis: number, isPrivate: boolean);
+        get rules(): games.jass.logic.data.models.rules.Rules;
+        get rulesSetType(): games.jass.logic.data.models.rules.RulesSetType;
+        get options(): games.jass.logic.data.models.table.config.Options;
+        get playersMode(): games.jass.logic.data.models.table.config.PlayersMode;
+        get pointsMode(): games.jass.logic.data.models.table.config.PointsMode;
+        get timeoutTimeMillis(): number;
+        get isPrivate(): boolean;
+        get playerHandCardsSize(): number;
+        copy(rules?: games.jass.logic.data.models.rules.Rules, rulesSetType?: games.jass.logic.data.models.rules.RulesSetType, options?: games.jass.logic.data.models.table.config.Options, playersMode?: games.jass.logic.data.models.table.config.PlayersMode, pointsMode?: games.jass.logic.data.models.table.config.PointsMode, timeoutTimeMillis?: number, isPrivate?: boolean): games.jass.logic.data.models.table.config.Config;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.config {
+    class ConfigLite {
+        constructor(players: games.jass.logic.data.models.table.config.PlayersMode, points: games.jass.logic.data.models.table.config.PointsMode, timeoutTimeMillis: number, rulesPreset: games.jass.logic.data.models.rules.RulesSetType, isPrivate: boolean, isChatEnabled: boolean, isBotsEnabled: boolean, rules: Nullable<games.jass.logic.data.models.rules.Rules>);
+        get players(): games.jass.logic.data.models.table.config.PlayersMode;
+        get points(): games.jass.logic.data.models.table.config.PointsMode;
+        get timeoutTimeMillis(): number;
+        get rulesPreset(): games.jass.logic.data.models.rules.RulesSetType;
+        get isPrivate(): boolean;
+        get isChatEnabled(): boolean;
+        get isBotsEnabled(): boolean;
+        get rules(): Nullable<games.jass.logic.data.models.rules.Rules>;
+        copy(players?: games.jass.logic.data.models.table.config.PlayersMode, points?: games.jass.logic.data.models.table.config.PointsMode, timeoutTimeMillis?: number, rulesPreset?: games.jass.logic.data.models.rules.RulesSetType, isPrivate?: boolean, isChatEnabled?: boolean, isBotsEnabled?: boolean, rules?: Nullable<games.jass.logic.data.models.rules.Rules>): games.jass.logic.data.models.table.config.ConfigLite;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.config {
+    class Options {
+        constructor(isEnableChat?: boolean, isBotsEnabled?: boolean, botIntelligenceLevel?: games.jass.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: boolean);
+        get isEnableChat(): boolean;
+        get isBotsEnabled(): boolean;
+        get botIntelligenceLevel(): games.jass.logic.data.models.table.config.BotIntelligenceLevel;
+        get timeForCountdownMillis(): number;
+        get timeForBotMillis(): number;
+        get isEnableChoosePartnerScreen(): boolean;
+        copy(isEnableChat?: boolean, isBotsEnabled?: boolean, botIntelligenceLevel?: games.jass.logic.data.models.table.config.BotIntelligenceLevel, timeForCountdownMillis?: number, timeForBotMillis?: number, isEnableChoosePartnerScreen?: boolean): games.jass.logic.data.models.table.config.Options;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            getServerOptions(isEnableChat?: boolean, isBotsEnabled?: boolean, isEnableChoosePartnerScreen?: boolean): games.jass.logic.data.models.table.config.Options;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.table.config {
+    abstract class PlayersMode {
+        private constructor();
+        static get TWO_PLAYERS(): games.jass.logic.data.models.table.config.PlayersMode & {
+            get name(): "TWO_PLAYERS";
+            get ordinal(): 0;
+        };
+        static get THREE_PLAYERS(): games.jass.logic.data.models.table.config.PlayersMode & {
+            get name(): "THREE_PLAYERS";
+            get ordinal(): 1;
+        };
+        static get FOUR_PLAYERS(): games.jass.logic.data.models.table.config.PlayersMode & {
+            get name(): "FOUR_PLAYERS";
+            get ordinal(): 2;
+        };
+        static get FOUR_PLAYERS_BY_TEAM(): games.jass.logic.data.models.table.config.PlayersMode & {
+            get name(): "FOUR_PLAYERS_BY_TEAM";
+            get ordinal(): 3;
+        };
+        get name(): "TWO_PLAYERS" | "THREE_PLAYERS" | "FOUR_PLAYERS" | "FOUR_PLAYERS_BY_TEAM";
+        get ordinal(): 0 | 1 | 2 | 3;
+        get value(): number;
+        get isTeamGame(): boolean;
+        get count(): number;
+        static values(): Array<games.jass.logic.data.models.table.config.PlayersMode>;
+        static valueOf(value: string): games.jass.logic.data.models.table.config.PlayersMode;
+        static get Companion(): {
+            create(points: number): games.jass.logic.data.models.table.config.PlayersMode;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.config {
+    abstract class PointsMode {
+        private constructor();
+        static get SMALL(): games.jass.logic.data.models.table.config.PointsMode & {
+            get name(): "SMALL";
+            get ordinal(): 0;
+        };
+        static get MEDIUM(): games.jass.logic.data.models.table.config.PointsMode & {
+            get name(): "MEDIUM";
+            get ordinal(): 1;
+        };
+        static get BIG(): games.jass.logic.data.models.table.config.PointsMode & {
+            get name(): "BIG";
+            get ordinal(): 2;
+        };
+        static get TEST(): games.jass.logic.data.models.table.config.PointsMode & {
+            get name(): "TEST";
+            get ordinal(): 3;
+        };
+        get name(): "SMALL" | "MEDIUM" | "BIG" | "TEST";
+        get ordinal(): 0 | 1 | 2 | 3;
+        get value(): number;
+        static values(): Array<games.jass.logic.data.models.table.config.PointsMode>;
+        static valueOf(value: string): games.jass.logic.data.models.table.config.PointsMode;
+        static get Companion(): {
+            create(points: number): games.jass.logic.data.models.table.config.PointsMode;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.history {
+    class GameHistory {
+        constructor(gameId: string, createdAt: any/* kotlinx.datetime.Instant */, rounds: Array<games.jass.logic.data.models.table.history.RoundHistory>, gameWinners: Nullable<Array<string>>, metadata: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>);
+        get gameId(): string;
+        get createdAt(): any/* kotlinx.datetime.Instant */;
+        get rounds(): Array<games.jass.logic.data.models.table.history.RoundHistory>;
+        get gameWinners(): Nullable<Array<string>>;
+        get metadata(): Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>;
+        get date(): string;
+        get lastRoundHistory(): games.jass.logic.data.models.table.history.RoundHistory;
+        get isFirstRound(): boolean;
+        get roundsCount(): number;
+        toString(): string;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(gameId?: string, createdAt?: any/* kotlinx.datetime.Instant */, rounds?: Array<games.jass.logic.data.models.table.history.RoundHistory>, gameWinners?: Nullable<Array<string>>, metadata?: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>): games.jass.logic.data.models.table.history.GameHistory;
+        static get Companion(): {
+            initial(gameId: string, createdAt?: any/* kotlinx.datetime.Instant */): games.jass.logic.data.models.table.history.GameHistory;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.table.history {
+    class GameHistoryMetadata {
+        constructor(randomData: Nullable<games.jass.logic.data.models.dealer.RandomData>, playersAnalytics: kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics>);
+        get randomData(): Nullable<games.jass.logic.data.models.dealer.RandomData>;
+        get playersAnalytics(): kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics>;
+        copy(randomData?: Nullable<games.jass.logic.data.models.dealer.RandomData>, playersAnalytics?: kotlin.collections.KtList<games.jass.logic.data.models.player.analytics.PlayerHistoryAnalytics>): games.jass.logic.data.models.table.history.GameHistoryMetadata;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            initial(): games.jass.logic.data.models.table.history.GameHistoryMetadata;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.table.history {
+    class RoundHistory {
+        constructor(round: number, items: Array<games.jass.logic.data.models.table.history.RoundHistoryItem>, committed: Nullable<Array<string>>, contractState: Nullable<games.jass.logic.data.models.player.state.RoundContractState>, winners: Nullable<Array<string>>, createdAt: any/* kotlinx.datetime.Instant */);
+        get roundNumber(): number;
+        get items(): Array<games.jass.logic.data.models.table.history.RoundHistoryItem>;
+        get roundCommitted(): Nullable<Array<string>>;
+        get roundContractState(): Nullable<games.jass.logic.data.models.player.state.RoundContractState>;
+        get roundWinners(): Nullable<Array<string>>;
+        get createdAt(): any/* kotlinx.datetime.Instant */;
+        isFailedRoundForPlayer(playerId: string): boolean;
+        get contractStateName(): Nullable<string>;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        toStringShort(): string;
+        copy(round?: number, items?: Array<games.jass.logic.data.models.table.history.RoundHistoryItem>, committed?: Nullable<Array<string>>, contractState?: Nullable<games.jass.logic.data.models.player.state.RoundContractState>, winners?: Nullable<Array<string>>, createdAt?: any/* kotlinx.datetime.Instant */): games.jass.logic.data.models.table.history.RoundHistory;
+        toString(): string;
+        static get Companion(): {
+            initial(roundNumber: number): games.jass.logic.data.models.table.history.RoundHistory;
+        };
+    }
+}
+export declare namespace games.jass.logic.data.models.table.history {
+    abstract class RoundHistoryItem {
+        protected constructor();
+        abstract get createdAt(): any/* kotlinx.datetime.Instant */;
+    }
+}
+export declare namespace games.jass.logic.data.models.table.round {
+    class Round {
+        constructor(roundNumber: number, numberOfBribe: Nullable<number>, trump: Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */);
+        get roundNumber(): number;
+        get numberOfBribe(): Nullable<number>;
+        get trump(): Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */;
+        get selectedTrump(): any/* io.raspberryapps.card_game.core.data.models.cards.Suit */;
+        get numberOfBribeOrZero(): number;
+        copy(roundNumber?: number, numberOfBribe?: Nullable<number>, trump?: Nullable<any>/* Nullable<io.raspberryapps.card_game.core.data.models.cards.Suit> */): games.jass.logic.data.models.table.round.Round;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static get Companion(): {
+            initial(): games.jass.logic.data.models.table.round.Round;
+        };
+    }
+}
+export declare namespace games.jass.logic.domain.interactors.dealer {
+    abstract class DealerStrategy {
+        private constructor();
+        static get FAKE(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "FAKE";
+            get ordinal(): 0;
+        };
+        static get BASED_ON_PREVIOUS(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "BASED_ON_PREVIOUS";
+            get ordinal(): 1;
+        };
+        static get EQUAL_HAND_BY_POINTS(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "EQUAL_HAND_BY_POINTS";
+            get ordinal(): 2;
+        };
+        static get EQUAL_HAND_BY_VALUE(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "EQUAL_HAND_BY_VALUE";
+            get ordinal(): 3;
+        };
+        static get RANDOM(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "RANDOM";
+            get ordinal(): 4;
+        };
+        static get RANDOM_ORG(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "RANDOM_ORG";
+            get ordinal(): 5;
+        };
+        static get RANDOM_ORG_SIGNED(): games.jass.logic.domain.interactors.dealer.DealerStrategy & {
+            get name(): "RANDOM_ORG_SIGNED";
+            get ordinal(): 6;
+        };
+        get name(): "FAKE" | "BASED_ON_PREVIOUS" | "EQUAL_HAND_BY_POINTS" | "EQUAL_HAND_BY_VALUE" | "RANDOM" | "RANDOM_ORG" | "RANDOM_ORG_SIGNED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        shouldEqualiseHand(): boolean;
+        static values(): Array<games.jass.logic.domain.interactors.dealer.DealerStrategy>;
+        static valueOf(value: string): games.jass.logic.domain.interactors.dealer.DealerStrategy;
+    }
+}
+export declare namespace games.jass.logic.redux.actions {
+    class ClearAction implements com.logic.redux.store.definitions.Action, com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished {
+        constructor(transition?: Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>);
+        get transition(): Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>;
+        copy(transition?: Nullable<games.jass.logic.redux.actions.mechanic.GameToRoomTransition>): games.jass.logic.redux.actions.ClearAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+        notValidateWhenFinishing(): boolean;
+        notValidateWhenFinished(): boolean;
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.redux.actions.client.from {
+    abstract class FromClientAction implements com.logic.redux.store.definitions.Action {
+        protected constructor();
+        abstract get playerId(): string;
+        abstract get fromBot(): boolean;
+        get actionTag(): string;
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.redux.actions.client.to {
+    class ActionDeliveryPayload {
+        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;
+        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(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 {
+        private constructor();
+        static get ROOM_ALL(): games.jass.logic.redux.actions.client.to.ActionDeliveryType & {
+            get name(): "ROOM_ALL";
+            get ordinal(): 0;
+        };
+        static get ROOM_EXCEPT_USER(): games.jass.logic.redux.actions.client.to.ActionDeliveryType & {
+            get name(): "ROOM_EXCEPT_USER";
+            get ordinal(): 1;
+        };
+        static get USER(): games.jass.logic.redux.actions.client.to.ActionDeliveryType & {
+            get name(): "USER";
+            get ordinal(): 2;
+        };
+        get name(): "ROOM_ALL" | "ROOM_EXCEPT_USER" | "USER";
+        get ordinal(): 0 | 1 | 2;
+        static values(): Array<games.jass.logic.redux.actions.client.to.ActionDeliveryType>;
+        static valueOf(value: string): games.jass.logic.redux.actions.client.to.ActionDeliveryType;
+        static get Companion(): {
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace games.jass.logic.redux.actions.client.to {
+    abstract class ToClientAction implements com.logic.redux.store.definitions.Action {
+        protected constructor();
+        abstract get deliveryPayload(): games.jass.logic.redux.actions.client.to.ActionDeliveryPayload;
+        get actionTag(): string;
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace games.jass.logic.redux.actions.game {
+    abstract class GameAction implements com.logic.redux.store.definitions.Action {
+        protected constructor();
+        get actionTag(): string;
+        readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
+    }
+    class RoundStartedAction extends games.jass.logic.redux.actions.game.GameAction {
+        constructor(id: string, gameId: string, roundNumber: number, players: Array<string>, isFirstRound: boolean, gameNumber: number, gameHistory: games.jass.logic.data.models.table.history.GameHistory);
+        get id(): string;
+        get gameId(): string;
+        get partyNumber(): number;
+        get players(): Array<string>;
+        get isFirstRound(): boolean;
+        get gameNumber(): number;
+        get gameHistory(): games.jass.logic.data.models.table.history.GameHistory;
+        toString(): string;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(id?: string, gameId?: string, roundNumber?: number, players?: Array<string>, isFirstRound?: boolean, gameNumber?: number, gameHistory?: games.jass.logic.data.models.table.history.GameHistory): games.jass.logic.redux.actions.game.RoundStartedAction;
+        get actionTag(): string;
+    }
+    class RoundEndedAction extends games.jass.logic.redux.actions.game.GameAction {
+        constructor(id: string, gameId: string, roundNumber: number, earnedBiggestPointPlayerId: string, gameLosers: Nullable<Array<string>> | undefined, gameWinners: Nullable<Array<string>> | undefined, playersGameAnalytics: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, playersRoundAnalytics: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, achievements: Nullable<Array<games.jass.logic.data.models.player.achievements.PlayerAchievements>>, gameHistory: games.jass.logic.data.models.table.history.GameHistory);
+        get id(): string;
+        get gameId(): string;
+        get roundNumber(): number;
+        get earnedBiggestPointPlayerId(): string;
+        get gameLosers(): Nullable<Array<string>>;
+        get gameWinners(): Nullable<Array<string>>;
+        get playersGameAnalytics(): Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>;
+        get playersRoundAnalytics(): Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>;
+        get achievements(): Nullable<Array<games.jass.logic.data.models.player.achievements.PlayerAchievements>>;
+        get gameHistory(): games.jass.logic.data.models.table.history.GameHistory;
+        get isGameFinished(): boolean;
+        toString(): string;
+        equals(other: Nullable<any>): boolean;
+        hashCode(): number;
+        copy(id?: string, gameId?: string, roundNumber?: number, earnedBiggestPointPlayerId?: string, gameLosers?: Nullable<Array<string>>, gameWinners?: Nullable<Array<string>>, playersGameAnalytics?: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, playersRoundAnalytics?: Nullable<Array<games.jass.logic.data.models.player.analytics.PlayerAnalytics>>, achievements?: Nullable<Array<games.jass.logic.data.models.player.achievements.PlayerAchievements>>, gameHistory?: games.jass.logic.data.models.table.history.GameHistory): games.jass.logic.redux.actions.game.RoundEndedAction;
+        get actionTag(): string;
+    }
+    class PartyRestartedAction implements com.logic.redux.store.definitions.Action {
+        constructor(id: string, roundNumber: number);
+        get id(): string;
+        get partyNumber(): number;
+        copy(id?: string, roundNumber?: number): games.jass.logic.redux.actions.game.PartyRestartedAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+        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>;
+        get playerIdsArray(): Array<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"];
+    }
+    interface FirstMechanicAction extends com.logic.redux.store.definitions.Action, com.logic.redux.actions.IgnoreBufferForAction {
+        readonly id: string;
+        readonly version: string;
+        readonly users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>;
+        readonly config: games.jass.logic.data.models.table.config.Config;
+        readonly gameCreatorPlayerId: string;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.jass.logic.redux.actions.mechanic.FirstMechanicAction": unique symbol;
+        } & 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, roomId: string, version: string, gameCreatorPlayerId: string, users: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>, aid: Nullable<string> | undefined, spectators: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>);
+        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>;
+        get aid(): Nullable<string>;
+        get spectators(): kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>;
+        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>, spectators?: kotlin.collections.KtList<com.logic.data.models.player.GameUserInfo>): games.jass.logic.redux.actions.mechanic.StartGameMechanicAction;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+        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, aid?: Nullable<string>);
+        get previousGameId(): string;
+        get gameId(): string;
+        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;
+        get actionTag(): string;
+    }
+    /* @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, 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>, isRoundHistorySaved?: boolean, 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 isRoundHistorySaved(): boolean;
+        get aid(): Nullable<string>;
+        toString(): string;
+        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>, isRoundHistorySaved?: boolean, 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>, 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, aid?: Nullable<string>);
+        get reason(): com.logic.data.models.TerminationGameReason;
+        get isGameFinished(): boolean;
+        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;
+        get actionTag(): string;
+        notValidateWhenFinishing(): boolean;
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.TerminatedAction["__doNotUseOrImplementIt"];
+    }
+    interface NavigationMechanicAction extends com.logic.redux.store.definitions.Action {
+        readonly sceneId: string;
+        readonly actId: Nullable<string>;
+        readonly actData: Nullable<games.jass.logic.data.models.scenes.ActData>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.jass.logic.redux.actions.mechanic.NavigationMechanicAction": unique symbol;
+        } & 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>, 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>, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.SceneMechanicAction;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.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.redux.store.definitions.Action {
+        readonly reason: com.logic.data.models.TerminationGameReason;
+        readonly isGameFinished: boolean;
+        readonly __doNotUseOrImplementIt: {
+            readonly "games.jass.logic.redux.actions.mechanic.TerminatedAction": unique symbol;
+        } & 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>, 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;
+        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>, aid?: Nullable<string>): games.jass.logic.redux.actions.mechanic.PlayerConnectionChangedMechanicAction;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        get actionTag(): string;
+        notValidateWhenFinishing(): boolean;
+        notValidateWhenFinished(): boolean;
+        readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
+    }
+}
+export declare const ERROR: string;
+export declare const DEBUG: string;
+export declare const WARN: string;
+export declare interface ParserHelper {
+    encodeFromClientEvent(action: games.jass.logic.redux.actions.client.from.FromClientAction): string;
+    decodeFromClientEvent(fromPlayerId: string, json: string): games.jass.logic.redux.actions.client.from.FromClientAction;
+    encodeToClientEvent(action: games.jass.logic.redux.actions.client.to.ToClientAction): string;
+    decodeToClientEventToMechanicActions(playerId: string, engine: games.jass.logic.GameStoreContract, json: string): Array<games.jass.logic.redux.actions.mechanic.MechanicAction>;
+    encodeGameRound(round: games.jass.logic.data.models.table.history.RoundHistory): string;
+    encodeGameRoundItems(round: games.jass.logic.data.models.table.history.RoundHistory): string;
+    encodeGameMetadata(metadata: games.jass.logic.data.models.table.history.GameHistoryMetadata): string;
+    encodeRoomConfig(config: models.RoomConfig): string;
+    decodeTableLite(json: string): games.jass.logic.data.models.table.JassTableLite;
+    decodeFullGameHistoryToTableLite(json: string, round: Nullable<number>): games.jass.logic.data.models.table.JassTableLite;
+    readonly __doNotUseOrImplementIt: {
+        readonly ParserHelper: unique symbol;
+    };
+}
+export declare interface RatingHelper {
+    isValidRatingForLeague(league: games.jass.logic.data.models.leagues.League, rating: number): boolean;
+    mapRatingToLeague(rating: number): games.jass.logic.data.models.leagues.League;
+    getLeaguesConfig(): games.jass.logic.data.models.leagues.LeaguesConfig;
+    readonly __doNotUseOrImplementIt: {
+        readonly RatingHelper: unique symbol;
+    };
+}
+export declare namespace di {
+    class EngineHelpersFactory {
+        constructor();
+        get ratingHelper(): RatingHelper;
+        get parserHelper(): ParserHelper;
+    }
+}
+export declare namespace models {
+    class RoomConfig {
+        constructor(players: number, points: number, timeoutTime: number, rulesPreset: string, isPrivate?: Nullable<boolean>, isChatEnabled?: Nullable<boolean>, rules?: Nullable<any>/* Nullable<com.logic.data.models.serializable.rules.RulesDto> */);
+        get players(): number;
+        get points(): number;
+        get timeoutTime(): number;
+        get rulesPreset(): string;
+        get isPrivate(): Nullable<boolean>;
+        get isChatEnabled(): Nullable<boolean>;
+        get rules(): Nullable<any>/* Nullable<com.logic.data.models.serializable.rules.RulesDto> */;
+        copy(players?: number, points?: number, timeoutTime?: number, rulesPreset?: string, isPrivate?: Nullable<boolean>, isChatEnabled?: Nullable<boolean>, rules?: Nullable<any>/* Nullable<com.logic.data.models.serializable.rules.RulesDto> */): models.RoomConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export as namespace io_raspberryapps_game_engine_engine;