game_client_logic_deb 1.8.341 → 1.8.345

package/Logic_Debertz-game_client.d.ts

@@ -1,4 +1,5 @@
 type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
 export declare namespace kotlin.collections {
     interface KtList<E> /* extends kotlin.collections.Collection<E> */ {
         asJsReadonlyArrayView(): ReadonlyArray<E>;
@@ -6,27 +7,48 @@ export declare namespace kotlin.collections {
             readonly "kotlin.collections.KtList": unique symbol;
         };
     }
-    const KtList: {
-        fromJsArray<E>(array: ReadonlyArray<E>): kotlin.collections.KtList<E>;
-    };
+    abstract class KtList<E> extends KtSingleton<KtList.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace KtList.$metadata$ {
+        abstract class constructor {
+            fromJsArray<E>(array: ReadonlyArray<E>): kotlin.collections.KtList<E>;
+            private constructor();
+        }
+    }
     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>;
-    };
+    abstract class KtSet<E> extends KtSingleton<KtSet.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace KtSet.$metadata$ {
+        abstract class constructor {
+            fromJsSet<E>(set: ReadonlySet<E>): kotlin.collections.KtSet<E>;
+            private constructor();
+        }
+    }
     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>;
-    };
+    abstract class KtMap<K, V> extends KtSingleton<KtMap.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace KtMap.$metadata$ {
+        abstract class constructor {
+            fromJsMap<K, V>(map: ReadonlyMap<K, V>): kotlin.collections.KtMap<K, V>;
+            private constructor();
+        }
+    }
 }
 export declare namespace games.raspberry.logger {
     interface LoggerEnabledTrigger extends games.raspberry.logger.RaspberryLogger {
@@ -72,6 +94,10 @@ export declare namespace games.raspberry.card_game.random.data.models {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CardDecksRequestUserData.$metadata$ {
+        const constructor: abstract new () => CardDecksRequestUserData;
+    }
     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>;
@@ -81,6 +107,10 @@ export declare namespace games.raspberry.card_game.random.data.models {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CardDeckRequestUserData.$metadata$ {
+        const constructor: abstract new () => CardDeckRequestUserData;
+    }
     class UserInfoData {
         constructor(id: string, name: string);
         get id(): string;
@@ -90,6 +120,10 @@ export declare namespace games.raspberry.card_game.random.data.models {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace UserInfoData.$metadata$ {
+        const constructor: abstract new () => UserInfoData;
+    }
 }
 export declare namespace games.raspberry.card_game.random.data.models {
     class GameCardDecksRecord {
@@ -102,10 +136,23 @@ export declare namespace games.raspberry.card_game.random.data.models {
         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;
-            nextRound(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;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameCardDecksRecord.$metadata$ {
+        const constructor: abstract new () => GameCardDecksRecord;
+    }
+    namespace GameCardDecksRecord {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                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;
+                nextRound(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;
+                private constructor();
+            }
+        }
     }
     class GameCardDeckData {
         constructor(cardDeckIndex: number, cards: kotlin.collections.KtList<number>);
@@ -116,6 +163,10 @@ export declare namespace games.raspberry.card_game.random.data.models {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameCardDeckData.$metadata$ {
+        const constructor: abstract new () => GameCardDeckData;
+    }
 }
 export declare namespace games.raspberry.card_game.random.data.models {
     class HttpConfig {
@@ -127,6 +178,10 @@ export declare namespace games.raspberry.card_game.random.data.models {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace HttpConfig.$metadata$ {
+        const constructor: abstract new () => HttpConfig;
+    }
 }
 export declare namespace games.raspberry.card_game.random.data.models {
     class RandomOrgConfig {
@@ -140,6 +195,10 @@ export declare namespace games.raspberry.card_game.random.data.models {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RandomOrgConfig.$metadata$ {
+        const constructor: abstract new () => RandomOrgConfig;
+    }
 }
 export declare namespace games.raspberry.card_game.random.data.providers {
     class PoolParams {
@@ -153,16 +212,34 @@ export declare namespace games.raspberry.card_game.random.data.providers {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PoolParams.$metadata$ {
+        const constructor: abstract new () => PoolParams;
+    }
 }
 export declare namespace io.raspberryapps.cardgame.core {
-    const CoreConfig: {
-        get version(): string;
-    };
+    abstract class CoreConfig extends KtSingleton<CoreConfig.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CoreConfig.$metadata$ {
+        abstract class constructor {
+            get version(): string;
+            private constructor();
+        }
+    }
 }
 export declare namespace com.logic {
-    const GameEngineConfig: {
-        get version(): string;
-    };
+    abstract class GameEngineConfig extends KtSingleton<GameEngineConfig.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameEngineConfig.$metadata$ {
+        abstract class constructor {
+            get version(): string;
+            private constructor();
+        }
+    }
 }
 export declare namespace com.logic.data.models {
     class CoreConfig {
@@ -176,17 +253,34 @@ export declare namespace com.logic.data.models {
         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;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CoreConfig.$metadata$ {
+        const constructor: abstract new () => CoreConfig;
+    }
+    namespace CoreConfig {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                getClientEngineTestMode(fileLogsEnabled: boolean, logsDirectoryPath: string, fileNameFormat?: string): com.logic.data.models.CoreConfig;
+                formatter(segment: string, gameId: string, roomId: string, userId: string): string;
+                private constructor();
+            }
+        }
     }
 }
 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 {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TerminationGameReason.$metadata$ {
+        const constructor: abstract new () => TerminationGameReason;
+    }
+    class PlayerLostConnectionReason extends com.logic.data.models.TerminationGameReason.$metadata$.constructor implements com.logic.data.models.FinishPlayerReason {
         constructor(playerId: string, tag: Nullable<string>);
         get playerId(): string;
         get tag(): Nullable<string>;
@@ -197,7 +291,11 @@ export declare namespace com.logic.data.models {
         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 {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerLostConnectionReason.$metadata$ {
+        const constructor: abstract new () => PlayerLostConnectionReason;
+    }
+    class PlayerTimeoutReason extends com.logic.data.models.TerminationGameReason.$metadata$.constructor implements com.logic.data.models.FinishPlayerReason {
         constructor(playerId: string, tag: Nullable<string>);
         get playerId(): string;
         get tag(): Nullable<string>;
@@ -208,7 +306,11 @@ export declare namespace com.logic.data.models {
         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 {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerTimeoutReason.$metadata$ {
+        const constructor: abstract new () => PlayerTimeoutReason;
+    }
+    class PlayerExitReason extends com.logic.data.models.TerminationGameReason.$metadata$.constructor implements com.logic.data.models.FinishPlayerReason {
         constructor(playerId: string);
         get playerId(): string;
         get connectionState(): com.logic.data.models.player.PlayerConnectionState;
@@ -218,6 +320,10 @@ export declare namespace com.logic.data.models {
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: com.logic.data.models.FinishPlayerReason["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerExitReason.$metadata$ {
+        const constructor: abstract new () => PlayerExitReason;
+    }
     interface FinishPlayerReason {
         readonly playerId: string;
         readonly connectionState: com.logic.data.models.player.PlayerConnectionState;
@@ -225,7 +331,7 @@ export declare namespace com.logic.data.models {
             readonly "com.logic.data.models.FinishPlayerReason": unique symbol;
         };
     }
-    class GameFinishedReason extends com.logic.data.models.TerminationGameReason {
+    class GameFinishedReason extends com.logic.data.models.TerminationGameReason.$metadata$.constructor {
         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;
@@ -233,6 +339,10 @@ export declare namespace com.logic.data.models {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameFinishedReason.$metadata$ {
+        const constructor: abstract new () => GameFinishedReason;
+    }
     namespace GameFinishedReason {
         abstract class Reason {
             private constructor();
@@ -264,11 +374,24 @@ export declare namespace com.logic.data.models {
             get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
             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 */;
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Reason.$metadata$ {
+            const constructor: abstract new () => Reason;
+        }
+        namespace Reason {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                    private constructor();
+                }
+            }
         }
     }
-    class GameErrorReason extends com.logic.data.models.TerminationGameReason {
+    class GameErrorReason extends com.logic.data.models.TerminationGameReason.$metadata$.constructor {
         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;
@@ -276,6 +399,10 @@ export declare namespace com.logic.data.models {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameErrorReason.$metadata$ {
+        const constructor: abstract new () => GameErrorReason;
+    }
     namespace GameErrorReason {
         abstract class Reason {
             private constructor();
@@ -307,20 +434,47 @@ export declare namespace com.logic.data.models {
             get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
             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 */;
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Reason.$metadata$ {
+            const constructor: abstract new () => Reason;
+        }
+        namespace Reason {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                    private constructor();
+                }
+            }
+        }
+    }
+    abstract class WaitingForConnectionReason extends KtSingleton<WaitingForConnectionReason.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace WaitingForConnectionReason.$metadata$ {
+        abstract class constructor extends com.logic.data.models.TerminationGameReason.$metadata$.constructor {
+            toString(): string;
+            hashCode(): number;
+            equals(other: Nullable<any>): boolean;
+            private constructor();
+        }
+    }
+    abstract class ProcessingReason extends KtSingleton<ProcessingReason.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ProcessingReason.$metadata$ {
+        abstract class constructor extends com.logic.data.models.TerminationGameReason.$metadata$.constructor {
+            toString(): string;
+            hashCode(): number;
+            equals(other: Nullable<any>): boolean;
+            private constructor();
         }
     }
-    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 {
@@ -339,6 +493,10 @@ export declare namespace com.logic.data.models.player {
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameUserInfo.$metadata$ {
+        const constructor: abstract new () => GameUserInfo;
+    }
 }
 export declare namespace com.logic.data.models.player {
     interface PlayerIdContract {
@@ -391,8 +549,21 @@ export declare namespace com.logic.data.models.player {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerConnectionState.$metadata$ {
+        const constructor: abstract new () => PlayerConnectionState;
+    }
+    namespace PlayerConnectionState {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.logic.redux.actions {
@@ -475,8 +646,21 @@ export declare namespace com.logic.utils.logger.outputs {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LogType.$metadata$ {
+        const constructor: abstract new () => LogType;
+    }
+    namespace LogType {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.logic.utils.logger.outputs {
@@ -499,8 +683,21 @@ export declare namespace com.logic.utils.logger.outputs {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LoggerOutputDataDto.$metadata$ {
+        const constructor: abstract new () => LoggerOutputDataDto;
+    }
+    namespace LoggerOutputDataDto {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic {
@@ -526,10 +723,23 @@ export declare namespace games.jass.logic.data.models {
         hashCode(): number;
         copy(dealerStrategy?: games.jass.logic.domain.interactors.dealer.DealerStrategy, isBotsAreHappy?: boolean, cards?: Nullable<Array<number>>, shuffleCardsPlayerNumber?: Nullable<number>, shouldDisplayDealerStrategy?: boolean): 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;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace DealerConfig.$metadata$ {
+        const constructor: abstract new () => DealerConfig;
+    }
+    namespace DealerConfig {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                getFromServerConfig(dealerStrategy?: string, cardsJson?: Nullable<string>): games.jass.logic.data.models.DealerConfig;
+                fake(cards?: Array<number>): games.jass.logic.data.models.DealerConfig;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models {
@@ -544,6 +754,10 @@ export declare namespace games.jass.logic.data.models {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace EngineBotConfig.$metadata$ {
+        const constructor: abstract new () => EngineBotConfig;
+    }
 }
 export declare namespace games.jass.logic.data.models {
     class EngineLogicConfig {
@@ -562,10 +776,23 @@ export declare namespace games.jass.logic.data.models {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-            getClientEngineTestMode(): games.jass.logic.data.models.EngineLogicConfig;
-            getServerEngineMode(roomMode: string, isPrivate: boolean, transition: Nullable<games.jass.logic.redux.actions.mechanic.GameTransition>, fromRound: Nullable<number>, isProduction: boolean, validateFromClientActionTags?: boolean, openRoomIfFinished?: boolean, playerTimeoutFactorToFinishStep?: number): games.jass.logic.data.models.EngineLogicConfig;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace EngineLogicConfig.$metadata$ {
+        const constructor: abstract new () => EngineLogicConfig;
+    }
+    namespace EngineLogicConfig {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                getClientEngineTestMode(): games.jass.logic.data.models.EngineLogicConfig;
+                getServerEngineMode(roomMode: string, isPrivate: boolean, transition: Nullable<games.jass.logic.redux.actions.mechanic.GameTransition>, fromRound: Nullable<number>, isProduction: boolean, validateFromClientActionTags?: boolean, openRoomIfFinished?: boolean, playerTimeoutFactorToFinishStep?: number): games.jass.logic.data.models.EngineLogicConfig;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models {
@@ -591,8 +818,21 @@ export declare namespace games.jass.logic.data.models {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameLifecycleState.$metadata$ {
+        const constructor: abstract new () => GameLifecycleState;
+    }
+    namespace GameLifecycleState {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models {
@@ -610,6 +850,10 @@ export declare namespace games.jass.logic.data.models {
         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;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameSessionAnalytics.$metadata$ {
+        const constructor: abstract new () => 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;
@@ -619,10 +863,14 @@ export declare namespace games.jass.logic.data.models {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CombinationPair.$metadata$ {
+        const constructor: abstract new () => CombinationPair;
+    }
 }
 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);
+        constructor(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsIntervalMillis?: number, serverStateUpdateIntervalMillis?: number);
         get finishGameIfAllBots(): boolean;
         get waitForPlayerToReconnect(): boolean;
         get waitForPlayerToReconnectTimeOutMillis(): number;
@@ -630,15 +878,30 @@ export declare namespace games.jass.logic.data.models.config {
         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;
+        get combinedEventsIntervalMillis(): number;
+        get serverStateUpdateIntervalMillis(): number;
+        copy(finishGameIfAllBots?: boolean, waitForPlayerToReconnect?: boolean, waitForPlayerToReconnectTimeOutMillis?: number, closeIfBotsAtFinish?: boolean, botReplacesPlayerAfterTimeout?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsIntervalMillis?: number, serverStateUpdateIntervalMillis?: 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;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ServerReduxConfig.$metadata$ {
+        const constructor: abstract new () => ServerReduxConfig;
+    }
+    namespace ServerReduxConfig {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                get DELAY_TO_BUFFER_EVENTS_MILLIS(): number;
+                get DELAY_TO_BUFFER_STATE_UPDATES_MILLIS(): number;
+                getServerEngineMode(finishGameIfAllBots: boolean, botReplacesPlayerAfterTimeout: boolean, closeIfBotsAtFinish: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsIntervalMillis?: number, serverStateUpdateIntervalMillis?: number): games.jass.logic.data.models.config.ServerReduxConfig;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.dealer {
@@ -653,6 +916,10 @@ export declare namespace games.jass.logic.data.models.dealer {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RandomData.$metadata$ {
+        const constructor: abstract new () => RandomData;
+    }
 }
 export declare namespace games.jass.logic.data.models.leagues {
     abstract class League {
@@ -683,6 +950,10 @@ export declare namespace games.jass.logic.data.models.leagues {
         static values(): Array<games.jass.logic.data.models.leagues.League>;
         static valueOf(value: string): games.jass.logic.data.models.leagues.League;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace League.$metadata$ {
+        const constructor: abstract new () => League;
+    }
 }
 export declare namespace games.jass.logic.data.models.leagues {
     class LeaguesConfig {
@@ -698,9 +969,22 @@ export declare namespace games.jass.logic.data.models.leagues {
         hashCode(): number;
         copy(initialUserRating?: number, minUserRating?: number, maxUserRating?: number, leagues?: Array<games.jass.logic.data.models.leagues.LeagueInfo>): games.jass.logic.data.models.leagues.LeaguesConfig;
         toString(): string;
-        static get Companion(): {
-            defaultConfig(): games.jass.logic.data.models.leagues.LeaguesConfig;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LeaguesConfig.$metadata$ {
+        const constructor: abstract new () => LeaguesConfig;
+    }
+    namespace LeaguesConfig {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                defaultConfig(): games.jass.logic.data.models.leagues.LeaguesConfig;
+                private constructor();
+            }
+        }
     }
     class LeagueInfo {
         constructor(league: games.jass.logic.data.models.leagues.League, minRating: number, maxRating: number, enabled: boolean);
@@ -713,6 +997,10 @@ export declare namespace games.jass.logic.data.models.leagues {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LeagueInfo.$metadata$ {
+        const constructor: abstract new () => LeagueInfo;
+    }
 }
 export declare namespace games.jass.logic.data.models.messages.combinatios {
     abstract class CombinationReason /* implements kotlin.Comparable<games.jass.logic.data.models.messages.combinatios.CombinationReason> */ {
@@ -750,6 +1038,10 @@ export declare namespace games.jass.logic.data.models.messages.combinatios {
         static values(): Array<games.jass.logic.data.models.messages.combinatios.CombinationReason>;
         static valueOf(value: string): games.jass.logic.data.models.messages.combinatios.CombinationReason;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CombinationReason.$metadata$ {
+        const constructor: abstract new () => CombinationReason;
+    }
 }
 export declare namespace games.jass.logic.data.models.player {
     class JassPlayerLite {
@@ -762,6 +1054,10 @@ export declare namespace games.jass.logic.data.models.player {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JassPlayerLite.$metadata$ {
+        const constructor: abstract new () => JassPlayerLite;
+    }
 }
 export declare namespace games.jass.logic.data.models.player {
     class UserProfilePayload {
@@ -773,6 +1069,10 @@ export declare namespace games.jass.logic.data.models.player {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace UserProfilePayload.$metadata$ {
+        const constructor: abstract new () => UserProfilePayload;
+    }
 }
 export declare namespace games.jass.logic.data.models.player.achievements {
     class Achievements {
@@ -785,6 +1085,10 @@ export declare namespace games.jass.logic.data.models.player.achievements {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Achievements.$metadata$ {
+        const constructor: abstract new () => Achievements;
+    }
 }
 export declare namespace games.jass.logic.data.models.player.achievements {
     class PlayerAchievements implements com.logic.data.models.player.PlayerIdContract {
@@ -798,6 +1102,10 @@ export declare namespace games.jass.logic.data.models.player.achievements {
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerAchievements.$metadata$ {
+        const constructor: abstract new () => PlayerAchievements;
+    }
 }
 export declare namespace games.jass.logic.data.models.player.analytics {
     class CombinationsAnalytics {
@@ -808,6 +1116,10 @@ export declare namespace games.jass.logic.data.models.player.analytics {
         copy(combinations?: Array<games.jass.logic.data.models.player.analytics.CombinationAnalytics>): games.jass.logic.data.models.player.analytics.CombinationsAnalytics;
         toString(): string;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CombinationsAnalytics.$metadata$ {
+        const constructor: abstract new () => CombinationsAnalytics;
+    }
     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;
@@ -818,6 +1130,10 @@ export declare namespace games.jass.logic.data.models.player.analytics {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CombinationAnalytics.$metadata$ {
+        const constructor: abstract new () => CombinationAnalytics;
+    }
 }
 export declare namespace games.jass.logic.data.models.player.analytics {
     class PlayerAnalytics implements com.logic.data.models.player.PlayerIdContract {
@@ -835,6 +1151,10 @@ export declare namespace games.jass.logic.data.models.player.analytics {
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerAnalytics.$metadata$ {
+        const constructor: abstract new () => PlayerAnalytics;
+    }
 }
 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 */ {
@@ -850,6 +1170,10 @@ export declare namespace games.jass.logic.data.models.player.analytics {
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerHistoryAnalytics.$metadata$ {
+        const constructor: abstract new () => PlayerHistoryAnalytics;
+    }
 }
 export declare namespace games.jass.logic.data.models.player.bids {
     abstract class BidType {
@@ -878,10 +1202,23 @@ export declare namespace games.jass.logic.data.models.player.bids {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace BidType.$metadata$ {
+        const constructor: abstract new () => BidType;
+    }
+    namespace BidType {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                get belotBalgarian(): Array<games.jass.logic.data.models.player.bids.BidType>;
+                get coinche(): Array<games.jass.logic.data.models.player.bids.BidType>;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.hand {
@@ -897,6 +1234,10 @@ export declare namespace games.jass.logic.data.models.player.hand {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CombinationRecord.$metadata$ {
+        const constructor: abstract new () => CombinationRecord;
+    }
 }
 export declare namespace games.jass.logic.data.models.player.points {
     abstract class PointsDistributeMode {
@@ -918,6 +1259,10 @@ export declare namespace games.jass.logic.data.models.player.points {
         static values(): Array<games.jass.logic.data.models.player.points.PointsDistributeMode>;
         static valueOf(value: string): games.jass.logic.data.models.player.points.PointsDistributeMode;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PointsDistributeMode.$metadata$ {
+        const constructor: abstract new () => PointsDistributeMode;
+    }
 }
 export declare namespace games.jass.logic.data.models.player.state {
     abstract class RoundContractState {
@@ -941,8 +1286,21 @@ export declare namespace games.jass.logic.data.models.player.state {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RoundContractState.$metadata$ {
+        const constructor: abstract new () => RoundContractState;
+    }
+    namespace RoundContractState {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.state {
@@ -968,9 +1326,22 @@ export declare namespace games.jass.logic.data.models.player.state {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RoundContractType.$metadata$ {
+        const constructor: abstract new () => RoundContractType;
+    }
+    namespace RoundContractType {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                get debertzContractTypes(): kotlin.collections.KtList<games.jass.logic.data.models.player.state.RoundContractType>;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.rules {
@@ -993,6 +1364,10 @@ export declare namespace games.jass.logic.data.models.rules {
         static values(): Array<games.jass.logic.data.models.rules.PutHigherTrumpCardMode>;
         static valueOf(value: string): games.jass.logic.data.models.rules.PutHigherTrumpCardMode;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PutHigherTrumpCardMode.$metadata$ {
+        const constructor: abstract new () => PutHigherTrumpCardMode;
+    }
 }
 export declare namespace games.jass.logic.data.models.rules {
     abstract class PutHigherTrumpCardPartnerMode {
@@ -1014,6 +1389,10 @@ export declare namespace games.jass.logic.data.models.rules {
         static values(): Array<games.jass.logic.data.models.rules.PutHigherTrumpCardPartnerMode>;
         static valueOf(value: string): games.jass.logic.data.models.rules.PutHigherTrumpCardPartnerMode;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PutHigherTrumpCardPartnerMode.$metadata$ {
+        const constructor: abstract new () => PutHigherTrumpCardPartnerMode;
+    }
 }
 export declare namespace games.jass.logic.data.models.rules {
     class Rules {
@@ -1049,17 +1428,30 @@ export declare namespace games.jass.logic.data.models.rules {
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
         copy(name?: Nullable<string>, 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>, needToPutHigherTrump?: boolean, trumpCardStepMode?: games.jass.logic.data.models.rules.PutHigherTrumpCardMode, trumpCardStepPartnerMode?: games.jass.logic.data.models.rules.PutHigherTrumpCardPartnerMode, combinationsWithFirstCard?: Array<games.jass.logic.data.models.table.combinations.CombinationType>, protectBella?: boolean, oneTryToProtectBella?: boolean, enableFourSevensCombination?: boolean, enableTrumpSevenCombination?: boolean, enableTrumpSevenCombinationAfterDistribution?: boolean, checkTrumpCombination?: boolean, checkOnlyTrumpDebertz?: 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;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Rules.$metadata$ {
+        const constructor: abstract new () => Rules;
+    }
+    namespace Rules {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                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;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.rules {
@@ -1097,6 +1489,10 @@ export declare namespace games.jass.logic.data.models.rules {
         static values(): Array<games.jass.logic.data.models.rules.RulesSetType>;
         static valueOf(value: string): games.jass.logic.data.models.rules.RulesSetType;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RulesSetType.$metadata$ {
+        const constructor: abstract new () => RulesSetType;
+    }
 }
 export declare namespace games.jass.logic.data.models.scenes {
     interface ActData {
@@ -1116,10 +1512,10 @@ export declare namespace games.jass.logic.data.models.scenes {
 }
 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> */, requestedCardDecks: kotlin.collections.KtList<any/* 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);
+        constructor(id: string, version: string, createdAt: any/* kotlin.time.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> */, requestedCardDecks: kotlin.collections.KtList<any/* 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 createdAt(): any/* kotlin.time.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 */>;
@@ -1132,7 +1528,7 @@ export declare namespace games.jass.logic.data.models.table {
         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 gameCreatedAt(): any/* kotlin.time.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;
@@ -1140,13 +1536,26 @@ export declare namespace games.jass.logic.data.models.table {
         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> */, requestedCardDecks?: kotlin.collections.KtList<any/* 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;
+        copy(id?: string, version?: string, createdAt?: any/* kotlin.time.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> */, requestedCardDecks?: kotlin.collections.KtList<any/* 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(roomId: string, gameId: string, version: string, tableLite: games.jass.logic.data.models.table.JassTableLite): games.jass.logic.data.models.table.JassTable;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JassTable.$metadata$ {
+        const constructor: abstract new () => JassTable;
+    }
+    namespace JassTable {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                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(roomId: string, gameId: string, version: string, tableLite: games.jass.logic.data.models.table.JassTableLite): games.jass.logic.data.models.table.JassTable;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table {
@@ -1161,6 +1570,10 @@ export declare namespace games.jass.logic.data.models.table {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JassTableLite.$metadata$ {
+        const constructor: abstract new () => JassTableLite;
+    }
 }
 export declare namespace games.jass.logic.data.models.table {
     class TableLoggerPayload implements games.raspberry.logger.LoggerPayload {
@@ -1174,6 +1587,10 @@ export declare namespace games.jass.logic.data.models.table {
         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"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TableLoggerPayload.$metadata$ {
+        const constructor: abstract new () => TableLoggerPayload;
+    }
     class PlayerLoggerPayload implements games.raspberry.logger.LoggerPayload {
         constructor(playerId: string, connectionState: Nullable<com.logic.data.models.player.PlayerConnectionState>);
         get playerId(): string;
@@ -1184,6 +1601,10 @@ export declare namespace games.jass.logic.data.models.table {
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: games.raspberry.logger.LoggerPayload["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerLoggerPayload.$metadata$ {
+        const constructor: abstract new () => PlayerLoggerPayload;
+    }
 }
 export declare namespace games.jass.logic.data.models.table {
     class TableStateWithActions {
@@ -1195,6 +1616,10 @@ export declare namespace games.jass.logic.data.models.table {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TableStateWithActions.$metadata$ {
+        const constructor: abstract new () => TableStateWithActions;
+    }
 }
 export declare namespace games.jass.logic.data.models.table.combinations {
     class Combination /* implements games.jass.logic.data.models.table.combinations.CombinationContract */ {
@@ -1204,6 +1629,10 @@ export declare namespace games.jass.logic.data.models.table.combinations {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Combination.$metadata$ {
+        const constructor: abstract new () => Combination;
+    }
 }
 export declare namespace games.jass.logic.data.models.table.combinations {
     abstract class CombinationState {
@@ -1236,8 +1665,21 @@ export declare namespace games.jass.logic.data.models.table.combinations {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CombinationState.$metadata$ {
+        const constructor: abstract new () => CombinationState;
+    }
+    namespace CombinationState {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.combinations {
@@ -1319,13 +1761,26 @@ export declare namespace games.jass.logic.data.models.table.combinations {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CombinationType.$metadata$ {
+        const constructor: abstract new () => CombinationType;
+    }
+    namespace CombinationType {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                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>;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.combinations {
@@ -1339,6 +1794,10 @@ export declare namespace games.jass.logic.data.models.table.combinations {
         toString(): string;
         readonly __doNotUseOrImplementIt: com.logic.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerCombinations.$metadata$ {
+        const constructor: abstract new () => PlayerCombinations;
+    }
 }
 export declare namespace games.jass.logic.data.models.table.config {
     abstract class BotIntelligenceLevel {
@@ -1367,8 +1826,21 @@ export declare namespace games.jass.logic.data.models.table.config {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace BotIntelligenceLevel.$metadata$ {
+        const constructor: abstract new () => BotIntelligenceLevel;
+    }
+    namespace BotIntelligenceLevel {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
     function getLevel(_this_: games.jass.logic.data.models.table.config.BotIntelligenceLevel): number;
 }
@@ -1392,6 +1864,10 @@ export declare namespace games.jass.logic.data.models.table.config {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Config.$metadata$ {
+        const constructor: abstract new () => Config;
+    }
 }
 export declare namespace games.jass.logic.data.models.table.config {
     class ConfigLite {
@@ -1411,6 +1887,10 @@ export declare namespace games.jass.logic.data.models.table.config {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ConfigLite.$metadata$ {
+        const constructor: abstract new () => ConfigLite;
+    }
 }
 export declare namespace games.jass.logic.data.models.table.config {
     class Options {
@@ -1425,9 +1905,22 @@ export declare namespace games.jass.logic.data.models.table.config {
         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;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Options.$metadata$ {
+        const constructor: abstract new () => Options;
+    }
+    namespace Options {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                getServerOptions(isEnableChat?: boolean, isBotsEnabled?: boolean, isEnableChoosePartnerScreen?: boolean): games.jass.logic.data.models.table.config.Options;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.config {
@@ -1456,9 +1949,22 @@ export declare namespace games.jass.logic.data.models.table.config {
         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(number: number): games.jass.logic.data.models.table.config.PlayersMode;
-        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayersMode.$metadata$ {
+        const constructor: abstract new () => PlayersMode;
+    }
+    namespace PlayersMode {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                create(number: number): games.jass.logic.data.models.table.config.PlayersMode;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.config {
@@ -1485,9 +1991,22 @@ export declare namespace games.jass.logic.data.models.table.config {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PointsMode.$metadata$ {
+        const constructor: abstract new () => PointsMode;
+    }
+    namespace PointsMode {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                create(points: number): games.jass.logic.data.models.table.config.PointsMode;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.config {
@@ -1508,6 +2027,10 @@ export declare namespace games.jass.logic.data.models.table.config {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RoomConfig.$metadata$ {
+        const constructor: abstract new () => RoomConfig;
+    }
 }
 export declare namespace games.jass.logic.data.models.table.config {
     abstract class RoomMode {
@@ -1536,6 +2059,10 @@ export declare namespace games.jass.logic.data.models.table.config {
         static values(): Array<games.jass.logic.data.models.table.config.RoomMode>;
         static valueOf(value: string): games.jass.logic.data.models.table.config.RoomMode;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RoomMode.$metadata$ {
+        const constructor: abstract new () => RoomMode;
+    }
 }
 export declare namespace games.jass.logic.data.models.table.history {
     class ClientGameHistory {
@@ -1547,12 +2074,16 @@ export declare namespace games.jass.logic.data.models.table.history {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ClientGameHistory.$metadata$ {
+        const constructor: abstract new () => ClientGameHistory;
+    }
 }
 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>);
+        constructor(gameId: string, createdAt: any/* kotlin.time.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 createdAt(): any/* kotlin.time.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>;
@@ -1563,10 +2094,23 @@ export declare namespace games.jass.logic.data.models.table.history {
         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;
-        };
+        copy(gameId?: string, createdAt?: any/* kotlin.time.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;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameHistory.$metadata$ {
+        const constructor: abstract new () => GameHistory;
+    }
+    namespace GameHistory {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                initial(gameId: string, createdAt?: any/* kotlin.time.Instant */): games.jass.logic.data.models.table.history.GameHistory;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.history {
@@ -1578,36 +2122,66 @@ export declare namespace games.jass.logic.data.models.table.history {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-            initial(): games.jass.logic.data.models.table.history.GameHistoryMetadata;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameHistoryMetadata.$metadata$ {
+        const constructor: abstract new () => GameHistoryMetadata;
+    }
+    namespace GameHistoryMetadata {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                initial(): games.jass.logic.data.models.table.history.GameHistoryMetadata;
+                private constructor();
+            }
+        }
     }
 }
 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 */);
+        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/* kotlin.time.Instant */);
         get round(): number;
         get items(): Array<games.jass.logic.data.models.table.history.RoundHistoryItem>;
         get committed(): Nullable<Array<string>>;
         get contractState(): Nullable<games.jass.logic.data.models.player.state.RoundContractState>;
         get winners(): Nullable<Array<string>>;
-        get createdAt(): any/* kotlinx.datetime.Instant */;
+        get createdAt(): any/* kotlin.time.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;
+        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/* kotlin.time.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;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RoundHistory.$metadata$ {
+        const constructor: abstract new () => RoundHistory;
+    }
+    namespace RoundHistory {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                initial(roundNumber: number): games.jass.logic.data.models.table.history.RoundHistory;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.history {
     abstract class RoundHistoryItem {
         protected constructor();
-        abstract get createdAt(): any/* kotlinx.datetime.Instant */;
+        abstract get createdAt(): any/* kotlin.time.Instant */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RoundHistoryItem.$metadata$ {
+        const constructor: abstract new () => RoundHistoryItem;
     }
 }
 export declare namespace games.jass.logic.data.models.table.round {
@@ -1623,9 +2197,22 @@ export declare namespace games.jass.logic.data.models.table.round {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-            initial(): games.jass.logic.data.models.table.round.Round;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Round.$metadata$ {
+        const constructor: abstract new () => Round;
+    }
+    namespace Round {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                initial(): games.jass.logic.data.models.table.round.Round;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.domain.interactors.dealer {
@@ -1674,9 +2261,22 @@ export declare namespace games.jass.logic.domain.interactors.dealer {
         isRandomOrg(): boolean;
         static values(): Array<games.jass.logic.domain.interactors.dealer.DealerStrategy>;
         static valueOf(value: string): games.jass.logic.domain.interactors.dealer.DealerStrategy;
-        static get Companion(): {
-            default(): games.jass.logic.domain.interactors.dealer.DealerStrategy;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace DealerStrategy.$metadata$ {
+        const constructor: abstract new () => DealerStrategy;
+    }
+    namespace DealerStrategy {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                default(): games.jass.logic.domain.interactors.dealer.DealerStrategy;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.redux.actions {
@@ -1692,6 +2292,10 @@ export declare namespace games.jass.logic.redux.actions {
         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"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ClearAction.$metadata$ {
+        const constructor: abstract new () => ClearAction;
+    }
 }
 export declare namespace games.jass.logic.redux.actions.client.from {
     abstract class FromClientAction implements com.logic.redux.store.definitions.Action {
@@ -1701,6 +2305,10 @@ export declare namespace games.jass.logic.redux.actions.client.from {
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace FromClientAction.$metadata$ {
+        const constructor: abstract new () => FromClientAction;
+    }
 }
 export declare namespace games.jass.logic.redux.actions.client.to {
     class ActionDeliveryPayload {
@@ -1717,10 +2325,23 @@ export declare namespace games.jass.logic.redux.actions.client.to {
         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;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ActionDeliveryPayload.$metadata$ {
+        const constructor: abstract new () => ActionDeliveryPayload;
+    }
+    namespace ActionDeliveryPayload {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                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;
+                private constructor();
+            }
+        }
     }
     abstract class ActionDeliveryType {
         private constructor();
@@ -1740,8 +2361,21 @@ export declare namespace games.jass.logic.redux.actions.client.to {
         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 */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ActionDeliveryType.$metadata$ {
+        const constructor: abstract new () => ActionDeliveryType;
+    }
+    namespace ActionDeliveryType {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.redux.actions.client.to {
@@ -1751,6 +2385,10 @@ export declare namespace games.jass.logic.redux.actions.client.to {
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ToClientAction.$metadata$ {
+        const constructor: abstract new () => ToClientAction;
+    }
 }
 export declare namespace games.jass.logic.redux.actions.game {
     abstract class GameAction implements com.logic.redux.store.definitions.Action {
@@ -1758,7 +2396,11 @@ export declare namespace games.jass.logic.redux.actions.game {
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
-    class RoundStartedAction extends games.jass.logic.redux.actions.game.GameAction {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameAction.$metadata$ {
+        const constructor: abstract new () => GameAction;
+    }
+    class RoundStartedAction extends games.jass.logic.redux.actions.game.GameAction.$metadata$.constructor {
         constructor(id: string, gameId: string, roundNumber: number, players: Array<string>, isFirstRound: boolean, gameNumber: number, roomMode: games.jass.logic.data.models.table.config.RoomMode, gameHistory: games.jass.logic.data.models.table.history.GameHistory);
         get id(): string;
         get gameId(): string;
@@ -1775,7 +2417,11 @@ export declare namespace games.jass.logic.redux.actions.game {
         copy(id?: string, gameId?: string, roundNumber?: number, players?: Array<string>, isFirstRound?: boolean, gameNumber?: number, roomMode?: games.jass.logic.data.models.table.config.RoomMode, 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 {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RoundStartedAction.$metadata$ {
+        const constructor: abstract new () => RoundStartedAction;
+    }
+    class RoundEndedAction extends games.jass.logic.redux.actions.game.GameAction.$metadata$.constructor {
         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;
@@ -1794,6 +2440,10 @@ export declare namespace games.jass.logic.redux.actions.game {
         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;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RoundEndedAction.$metadata$ {
+        const constructor: abstract new () => RoundEndedAction;
+    }
     class PartyRestartedAction implements com.logic.redux.store.definitions.Action {
         constructor(id: string, roundNumber: number);
         get id(): string;
@@ -1805,6 +2455,10 @@ export declare namespace games.jass.logic.redux.actions.game {
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PartyRestartedAction.$metadata$ {
+        const constructor: abstract new () => PartyRestartedAction;
+    }
 }
 export declare namespace games.jass.logic.redux.actions.mechanic {
     interface GameTransition {
@@ -1827,6 +2481,10 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         get readyPlayerIdsArray(): Array<string>;
         readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.GameTransition["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RevengeRoomTransition.$metadata$ {
+        const constructor: abstract new () => RevengeRoomTransition;
+    }
     class GameToRoomTransition implements games.jass.logic.redux.actions.mechanic.GameTransition {
         constructor(roomId: string, playerIds: Nullable<kotlin.collections.KtList<string>>, previousPlayers: Nullable<kotlin.collections.KtList<string>>);
         get roomId(): string;
@@ -1840,6 +2498,10 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.GameTransition["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameToRoomTransition.$metadata$ {
+        const constructor: abstract new () => GameToRoomTransition;
+    }
 }
 export declare namespace games.jass.logic.redux.actions.mechanic {
     abstract class MechanicAction implements com.logic.redux.actions.BufferedAction {
@@ -1848,6 +2510,10 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: com.logic.redux.actions.BufferedAction["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace MechanicAction.$metadata$ {
+        const constructor: abstract new () => MechanicAction;
+    }
     interface FirstMechanicAction extends com.logic.redux.store.definitions.Action, com.logic.redux.actions.IgnoreBufferForAction {
         readonly id: string;
         readonly version: string;
@@ -1858,7 +2524,7 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
             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 {
+    class StartGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor 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;
@@ -1874,7 +2540,11 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         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 {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace StartGameMechanicAction.$metadata$ {
+        const constructor: abstract new () => StartGameMechanicAction;
+    }
+    class StartNewGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor {
         constructor(previousGameId: string, gameId: string, aid?: Nullable<string>);
         get previousGameId(): string;
         get gameId(): string;
@@ -1885,8 +2555,11 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         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 {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace StartNewGameMechanicAction.$metadata$ {
+        const constructor: abstract new () => StartNewGameMechanicAction;
+    }
+    class FinishingGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor 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.GameTransition>, 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;
@@ -1902,12 +2575,25 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         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(): {
-            fromTableWithAnalytics(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.GameTransition>): games.jass.logic.redux.actions.mechanic.FinishingGameMechanicAction;
-            fromTable(table: Nullable<games.jass.logic.data.models.table.JassTable>): 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 {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace FinishingGameMechanicAction.$metadata$ {
+        const constructor: abstract new () => FinishingGameMechanicAction;
+    }
+    namespace FinishingGameMechanicAction {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                fromTableWithAnalytics(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.GameTransition>): games.jass.logic.redux.actions.mechanic.FinishingGameMechanicAction;
+                fromTable(table: Nullable<games.jass.logic.data.models.table.JassTable>): games.jass.logic.redux.actions.mechanic.FinishingGameMechanicAction;
+                private constructor();
+            }
+        }
+    }
+    class FinishGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor 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>, transition?: Nullable<games.jass.logic.redux.actions.mechanic.GameTransition>);
         get reason(): com.logic.data.models.TerminationGameReason;
         get isGameFinished(): boolean;
@@ -1921,6 +2607,10 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         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"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace FinishGameMechanicAction.$metadata$ {
+        const constructor: abstract new () => FinishGameMechanicAction;
+    }
     interface NavigationMechanicAction extends com.logic.redux.store.definitions.Action {
         readonly sceneId: string;
         readonly actId: Nullable<string>;
@@ -1929,7 +2619,7 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
             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.data.models.player.PlayerIdContract, com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished/*, games.jass.logic.redux.actions.mechanic.NextPlayerTurnAction, games.jass.logic.redux.actions.mechanic.PlayerTurnIdAnswerAction */ {
+    class SceneMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor implements games.jass.logic.redux.actions.mechanic.NavigationMechanicAction, com.logic.redux.store.definitions.Action, com.logic.redux.actions.ReleaseBufferTriggerAction, com.logic.data.models.player.PlayerIdContract, com.logic.redux.actions.validation.NotValidateIfGameFinishing, com.logic.redux.actions.validation.NotValidateIfGameFinished/*, games.jass.logic.redux.actions.mechanic.NextPlayerTurnAction, games.jass.logic.redux.actions.mechanic.PlayerTurnIdAnswerAction */ {
         constructor(currentTurnPlayerId: Nullable<string>, 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>;
@@ -1946,6 +2636,10 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         get playerId(): 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.data.models.player.PlayerIdContract["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinishing["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace SceneMechanicAction.$metadata$ {
+        const constructor: abstract new () => SceneMechanicAction;
+    }
     interface TerminatedAction extends com.logic.redux.store.definitions.Action {
         readonly reason: com.logic.data.models.TerminationGameReason;
         readonly isGameFinished: boolean;
@@ -1954,7 +2648,7 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
             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 {
+    class PlayerConnectionChangedMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor 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;
@@ -1973,6 +2667,10 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         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"];
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlayerConnectionChangedMechanicAction.$metadata$ {
+        const constructor: abstract new () => PlayerConnectionChangedMechanicAction;
+    }
 }
 export declare interface GameHelper {
     filterLivePlayers(store: com.logic.redux.store.definitions.Store<any/* games.jass.logic.redux.AppState */>, playerIds: Array<string>): Array<string>;
@@ -2044,6 +2742,10 @@ export declare namespace di {
         get gameHelper(): GameHelper;
         get gameResources(): GameResources;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace EngineHelpersFactory.$metadata$ {
+        const constructor: abstract new () => EngineHelpersFactory;
+    }
 }
 export declare namespace games.jass.logic.client.data.models.config {
     abstract class GameType {
@@ -2072,8 +2774,21 @@ export declare namespace games.jass.logic.client.data.models.config {
         get ordinal(): 0 | 1 | 2 | 3 | 4;
         static values(): Array<games.jass.logic.client.data.models.config.GameType>;
         static valueOf(value: string): games.jass.logic.client.data.models.config.GameType;
-        static get Companion(): {
-        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameType.$metadata$ {
+        const constructor: abstract new () => GameType;
+    }
+    namespace GameType {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.client.data.models.config {
@@ -2090,16 +2805,29 @@ export declare namespace games.jass.logic.client.data.models.config {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-            getClientEngineTestMode(): games.jass.logic.client.data.models.config.GameClientConfig;
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameClientConfig.$metadata$ {
+        const constructor: abstract new () => GameClientConfig;
+    }
+    namespace GameClientConfig {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                getClientEngineTestMode(): games.jass.logic.client.data.models.config.GameClientConfig;
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.client.data.models.vm {
     class GameHistoryViewModel /* extends games.jass.logic.client.data.models.vm.HistoryViewModel */ {
-        constructor(gameId: string, createdAt: any/* kotlinx.datetime.Instant */, gameType: games.jass.logic.client.data.models.config.GameType, users: Array<com.logic.data.models.player.GameUserInfo>, config: games.jass.logic.data.models.table.config.ConfigLite, gameWinners: Nullable<Array<string>>, metadata: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>);
+        constructor(gameId: string, createdAt: any/* kotlin.time.Instant */, gameType: games.jass.logic.client.data.models.config.GameType, users: Array<com.logic.data.models.player.GameUserInfo>, config: games.jass.logic.data.models.table.config.ConfigLite, gameWinners: Nullable<Array<string>>, metadata: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>);
         get gameId(): string;
-        get createdAt(): any/* kotlinx.datetime.Instant */;
+        get createdAt(): any/* kotlin.time.Instant */;
         get gameType(): games.jass.logic.client.data.models.config.GameType;
         get users(): Array<com.logic.data.models.player.GameUserInfo>;
         get config(): games.jass.logic.data.models.table.config.ConfigLite;
@@ -2108,7 +2836,11 @@ export declare namespace games.jass.logic.client.data.models.vm {
         equals(other: Nullable<any>): boolean;
         hashCode(): number;
         toString(): string;
-        copy(gameId?: string, createdAt?: any/* kotlinx.datetime.Instant */, gameType?: games.jass.logic.client.data.models.config.GameType, users?: Array<com.logic.data.models.player.GameUserInfo>, config?: games.jass.logic.data.models.table.config.ConfigLite, gameWinners?: Nullable<Array<string>>, metadata?: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>): games.jass.logic.client.data.models.vm.GameHistoryViewModel;
+        copy(gameId?: string, createdAt?: any/* kotlin.time.Instant */, gameType?: games.jass.logic.client.data.models.config.GameType, users?: Array<com.logic.data.models.player.GameUserInfo>, config?: games.jass.logic.data.models.table.config.ConfigLite, gameWinners?: Nullable<Array<string>>, metadata?: Nullable<games.jass.logic.data.models.table.history.GameHistoryMetadata>): games.jass.logic.client.data.models.vm.GameHistoryViewModel;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GameHistoryViewModel.$metadata$ {
+        const constructor: abstract new () => GameHistoryViewModel;
     }
     class RoundEndedHistoryViewModel /* extends games.jass.logic.client.data.models.vm.HistoryViewModel */ {
         constructor(gameId: string, roundNumber: number, items: Array<games.jass.logic.data.models.table.history.RoundHistoryItem>, roundContractState: Nullable<games.jass.logic.data.models.player.state.RoundContractState>, roundCommitted: Nullable<Array<string>>, roundWinners: Nullable<Array<string>>, gameEndedHistory: Nullable<games.jass.logic.client.data.models.vm.GameHistoryViewModel>);
@@ -2124,6 +2856,10 @@ export declare namespace games.jass.logic.client.data.models.vm {
         copy(gameId?: string, roundNumber?: number, items?: Array<games.jass.logic.data.models.table.history.RoundHistoryItem>, roundContractState?: Nullable<games.jass.logic.data.models.player.state.RoundContractState>, roundCommitted?: Nullable<Array<string>>, roundWinners?: Nullable<Array<string>>, gameEndedHistory?: Nullable<games.jass.logic.client.data.models.vm.GameHistoryViewModel>): games.jass.logic.client.data.models.vm.RoundEndedHistoryViewModel;
         toString(): string;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RoundEndedHistoryViewModel.$metadata$ {
+        const constructor: abstract new () => RoundEndedHistoryViewModel;
+    }
 }
 export declare namespace games.jass.logic.client.domain.mechanic {
     interface GameMechanic extends games.jass.logic.GameStoreContract/*, games.jass.logic.client.domain.scenes.PlayersSceneContract */ {