game_client_logic_deb 1.8.451 → 1.8.453

package/Logic_Debertz-game_client.d.ts

@@ -7,15 +7,8 @@ export declare namespace kotlin.collections {
             readonly "kotlin.collections.KtList": unique symbol;
         };
     }
-    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();
-        }
+    namespace KtList {
+        function fromJsArray<E>(array: ReadonlyArray<E>): kotlin.collections.KtList<E>;
     }
     interface KtSet<E> /* extends kotlin.collections.Collection<E> */ {
         asJsReadonlySetView(): ReadonlySet<E>;
@@ -23,15 +16,8 @@ export declare namespace kotlin.collections {
             readonly "kotlin.collections.KtSet": unique symbol;
         };
     }
-    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();
-        }
+    namespace KtSet {
+        function fromJsSet<E>(set: ReadonlySet<E>): kotlin.collections.KtSet<E>;
     }
     interface KtMap<K, V> {
         asJsReadonlyMapView(): ReadonlyMap<K, V>;
@@ -39,14 +25,24 @@ export declare namespace kotlin.collections {
             readonly "kotlin.collections.KtMap": unique symbol;
         };
     }
-    abstract class KtMap<K, V> extends KtSingleton<KtMap.$metadata$.constructor>() {
-        private constructor();
+    namespace KtMap {
+        function fromJsMap<K, V>(map: ReadonlyMap<K, V>): kotlin.collections.KtMap<K, V>;
     }
-    /** @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 kotlin {
+    class Pair<A, B> /* implements kotlin.io.Serializable */ {
+        constructor(first: A, second: B);
+        get first(): A;
+        get second(): B;
+        toString(): string;
+        copy(first?: A, second?: B): kotlin.Pair<A, B>;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    namespace Pair {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new <A, B>() => Pair<A, B>;
         }
     }
 }
@@ -84,6 +80,10 @@ export declare namespace games.raspberry.logger.output {
         };
     }
 }
+export declare namespace io.ktor.client.engine.js {
+    /** @deprecated  */
+    const initHook: any;
+}
 export declare namespace games.raspberry.card_game.random.data.models {
     class CardDecksRequestUserData {
         constructor(id: string, count: number);
@@ -94,9 +94,11 @@ 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;
+    namespace CardDecksRequestUserData {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => CardDecksRequestUserData;
+        }
     }
     class CardDeckRequestUserData {
         constructor(players: kotlin.collections.KtList<games.raspberry.card_game.random.data.models.UserInfoData>, gameId: string);
@@ -107,9 +109,11 @@ 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;
+    namespace CardDeckRequestUserData {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => CardDeckRequestUserData;
+        }
     }
     class UserInfoData {
         constructor(id: string, name: string);
@@ -120,9 +124,11 @@ 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;
+    namespace UserInfoData {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => UserInfoData;
+        }
     }
 }
 export declare namespace games.raspberry.card_game.random.data.models {
@@ -137,20 +143,22 @@ 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 GameCardDecksRecord.$metadata$ {
-        const constructor: abstract new () => GameCardDecksRecord;
-    }
     namespace 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 $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $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();
+                }
             }
         }
     }
@@ -163,9 +171,11 @@ 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;
+    namespace GameCardDeckData {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => GameCardDeckData;
+        }
     }
 }
 export declare namespace games.raspberry.card_game.random.data.models {
@@ -178,9 +188,11 @@ 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;
+    namespace HttpConfig {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => HttpConfig;
+        }
     }
 }
 export declare namespace games.raspberry.card_game.random.data.models {
@@ -195,9 +207,11 @@ 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;
+    namespace RandomOrgConfig {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => RandomOrgConfig;
+        }
     }
 }
 export declare namespace games.raspberry.card_game.random.data.providers {
@@ -212,20 +226,24 @@ 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;
+    namespace PoolParams {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => PoolParams;
+        }
     }
 }
 export declare namespace io.raspberryapps.cardgame.core {
     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();
+    namespace CoreConfig {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                get version(): string;
+                private constructor();
+            }
         }
     }
 }
@@ -233,11 +251,13 @@ export declare namespace com.logic {
     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();
+    namespace GameEngineConfig {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                get version(): string;
+                private constructor();
+            }
         }
     }
 }
@@ -254,20 +274,22 @@ 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 CoreConfig.$metadata$ {
-        const constructor: abstract new () => CoreConfig;
-    }
     namespace CoreConfig {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $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();
+                }
             }
         }
     }
@@ -276,9 +298,11 @@ export declare namespace com.logic.data.models {
     abstract class TerminationGameReason {
         protected 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 TerminationGameReason.$metadata$ {
-        const constructor: abstract new () => TerminationGameReason;
+    namespace TerminationGameReason {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $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>);
@@ -290,9 +314,11 @@ 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 PlayerLostConnectionReason.$metadata$ {
-        const constructor: abstract new () => PlayerLostConnectionReason;
+    namespace PlayerLostConnectionReason {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $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>);
@@ -304,9 +330,11 @@ 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 PlayerTimeoutReason.$metadata$ {
-        const constructor: abstract new () => PlayerTimeoutReason;
+    namespace PlayerTimeoutReason {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $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);
@@ -317,9 +345,11 @@ 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;
+    namespace PlayerExitReason {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => PlayerExitReason;
+        }
     }
     interface FinishPlayerReason {
         readonly playerId: string;
@@ -335,11 +365,11 @@ 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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => GameFinishedReason;
+        }
         abstract class Reason {
             private constructor();
             static get DEPLOY(): com.logic.data.models.GameFinishedReason.Reason & {
@@ -371,19 +401,10 @@ export declare namespace com.logic.data.models {
             static values(): Array<com.logic.data.models.GameFinishedReason.Reason>;
             static valueOf(value: string): com.logic.data.models.GameFinishedReason.Reason;
         }
-        /** @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();
-                }
+            namespace $metadata$ {
+                const constructor: abstract new () => Reason;
             }
         }
     }
@@ -395,11 +416,11 @@ 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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => GameErrorReason;
+        }
         abstract class Reason {
             private constructor();
             static get SERVER_ERROR(): com.logic.data.models.GameErrorReason.Reason & {
@@ -431,44 +452,39 @@ export declare namespace com.logic.data.models {
             static values(): Array<com.logic.data.models.GameErrorReason.Reason>;
             static valueOf(value: string): com.logic.data.models.GameErrorReason.Reason;
         }
-        /** @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();
-                }
+            namespace $metadata$ {
+                const constructor: abstract new () => Reason;
             }
         }
     }
     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();
+    namespace WaitingForConnectionReason {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $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();
+    namespace ProcessingReason {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor extends com.logic.data.models.TerminationGameReason.$metadata$.constructor {
+                toString(): string;
+                hashCode(): number;
+                equals(other: Nullable<any>): boolean;
+                private constructor();
+            }
         }
     }
 }
@@ -489,9 +505,11 @@ 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;
+    namespace GameUserInfo {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => GameUserInfo;
+        }
     }
 }
 export declare namespace com.logic.data.models.player {
@@ -558,19 +576,10 @@ export declare namespace com.logic.data.models.player {
         static values(): Array<com.logic.data.models.player.PlayerConnectionState>;
         static valueOf(value: string): com.logic.data.models.player.PlayerConnectionState;
     }
-    /** @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();
-            }
+        namespace $metadata$ {
+            const constructor: abstract new () => PlayerConnectionState;
         }
     }
 }
@@ -586,9 +595,11 @@ export declare namespace com.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 Team.$metadata$ {
-        const constructor: abstract new () => Team;
+    namespace Team {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => Team;
+        }
     }
 }
 export declare namespace com.logic.redux.actions {
@@ -680,19 +691,10 @@ export declare namespace com.logic.utils.logger.outputs {
         static values(): Array<com.logic.utils.logger.outputs.LogType>;
         static valueOf(value: string): com.logic.utils.logger.outputs.LogType;
     }
-    /** @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();
-            }
+        namespace $metadata$ {
+            const constructor: abstract new () => LogType;
         }
     }
 }
@@ -717,19 +719,10 @@ export declare namespace com.logic.utils.logger.outputs {
         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 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();
-            }
+        namespace $metadata$ {
+            const constructor: abstract new () => LoggerOutputDataDto;
         }
     }
 }
@@ -759,20 +752,22 @@ export declare namespace games.jass.logic.data.models {
         copy(dealerStrategy?: games.jass.logic.domain.interactors.dealer.DealerStrategy, cardsInCycle?: number, isBotsAreHappy?: boolean, cards?: Nullable<Array<number>>, shuffleCardsPlayerNumber?: Nullable<number>, shouldDisplayDealerStrategy?: boolean): games.jass.logic.data.models.DealerConfig;
         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 DealerConfig.$metadata$ {
-        const constructor: abstract new () => DealerConfig;
-    }
     namespace 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 $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $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();
+                }
             }
         }
     }
@@ -791,19 +786,21 @@ 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;
-    }
     namespace EngineBotConfig {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => EngineBotConfig;
+        }
         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 {
-                getServerEngineMode(enableBotChat: boolean, openAiApiKey: Nullable<string>): games.jass.logic.data.models.EngineBotConfig;
-                private constructor();
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    getServerEngineMode(enableBotChat: boolean, openAiApiKey: Nullable<string>): games.jass.logic.data.models.EngineBotConfig;
+                    private constructor();
+                }
             }
         }
     }
@@ -827,20 +824,22 @@ 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 EngineLogicConfig.$metadata$ {
-        const constructor: abstract new () => EngineLogicConfig;
-    }
     namespace 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 $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $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();
+                }
             }
         }
     }
@@ -874,19 +873,10 @@ export declare namespace games.jass.logic.data.models {
         static values(): Array<games.jass.logic.data.models.GameLifecycleState>;
         static valueOf(value: string): games.jass.logic.data.models.GameLifecycleState;
     }
-    /** @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();
-            }
+        namespace $metadata$ {
+            const constructor: abstract new () => GameLifecycleState;
         }
     }
 }
@@ -905,9 +895,11 @@ 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;
+    namespace 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 $metadata$ {
+            const constructor: abstract new () => GameSessionAnalytics;
+        }
     }
     class CombinationPair {
         constructor(type: games.jass.logic.data.models.table.combinations.CombinationType, count: number);
@@ -918,9 +910,11 @@ 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;
+    namespace CombinationPair {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => CombinationPair;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.config {
@@ -943,9 +937,11 @@ export declare namespace games.jass.logic.data.models.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 RatingConfig.$metadata$ {
-        const constructor: abstract new () => RatingConfig;
+    namespace RatingConfig {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => RatingConfig;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.config {
@@ -967,21 +963,23 @@ export declare namespace games.jass.logic.data.models.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 ServerReduxConfig.$metadata$ {
-        const constructor: abstract new () => ServerReduxConfig;
-    }
     namespace 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 $metadata$ {
+            const constructor: abstract new () => 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(botReplacesPlayerAfterTimeout: boolean, closeIfBotsAtFinish?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsIntervalMillis?: number, serverStateUpdateIntervalMillis?: number): games.jass.logic.data.models.config.ServerReduxConfig;
-                private constructor();
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    get DELAY_TO_BUFFER_EVENTS_MILLIS(): number;
+                    get DELAY_TO_BUFFER_STATE_UPDATES_MILLIS(): number;
+                    getServerEngineMode(botReplacesPlayerAfterTimeout: boolean, closeIfBotsAtFinish?: boolean, enabledCombinedEvents?: boolean, delayToAskBotMillis?: number, combinedEventsIntervalMillis?: number, serverStateUpdateIntervalMillis?: number): games.jass.logic.data.models.config.ServerReduxConfig;
+                    private constructor();
+                }
             }
         }
     }
@@ -1000,9 +998,11 @@ 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;
+    namespace RandomData {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => RandomData;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.leagues {
@@ -1015,9 +1015,11 @@ 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 EngineSettings.$metadata$ {
-        const constructor: abstract new () => EngineSettings;
+    namespace EngineSettings {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => EngineSettings;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.leagues {
@@ -1049,9 +1051,11 @@ 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;
+    namespace 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 $metadata$ {
+            const constructor: abstract new () => League;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.leagues {
@@ -1069,19 +1073,21 @@ export declare namespace games.jass.logic.data.models.leagues {
         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;
     }
-    /** @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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    defaultConfig(): games.jass.logic.data.models.leagues.LeaguesConfig;
+                    private constructor();
+                }
             }
         }
     }
@@ -1096,9 +1102,11 @@ 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;
+    namespace LeagueInfo {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => LeagueInfo;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.messages {
@@ -1113,24 +1121,28 @@ export declare namespace games.jass.logic.data.models.messages {
             readonly "games.jass.logic.data.models.messages.Message": unique symbol;
         };
     }
-    abstract class Message extends KtSingleton<Message.$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 Message.$metadata$ {
-        abstract class constructor {
-            get WHO_SHUFFLE_CARDS_TYPE(): string;
-            get PHRASE_MESSAGE_TYPE(): string;
-            get STICKER_MESSAGE_TYPE(): string;
-            get COMBINATIONS_MESSAGE_TYPE(): string;
-            get POINTS_MESSAGE_TYPE(): string;
-            get TEXT_MESSAGE_TYPE(): string;
-            get WINNER_COMBINATIONS_MESSAGE_TYPE(): string;
-            get VALIDATION_MESSAGE_TYPE(): string;
-            get EVENT_MESSAGE_TYPE(): string;
-            get RANDOM_SIGNATURE_MESSAGE_TYPE(): string;
+    namespace Message {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
             private constructor();
         }
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    get WHO_SHUFFLE_CARDS_TYPE(): string;
+                    get PHRASE_MESSAGE_TYPE(): string;
+                    get STICKER_MESSAGE_TYPE(): string;
+                    get COMBINATIONS_MESSAGE_TYPE(): string;
+                    get POINTS_MESSAGE_TYPE(): string;
+                    get TEXT_MESSAGE_TYPE(): string;
+                    get WINNER_COMBINATIONS_MESSAGE_TYPE(): string;
+                    get VALIDATION_MESSAGE_TYPE(): string;
+                    get EVENT_MESSAGE_TYPE(): string;
+                    get RANDOM_SIGNATURE_MESSAGE_TYPE(): string;
+                    private constructor();
+                }
+            }
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.messages {
@@ -1181,9 +1193,11 @@ 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;
+    namespace 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 $metadata$ {
+            const constructor: abstract new () => CombinationReason;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.messages.text {
@@ -1206,9 +1220,11 @@ export declare namespace games.jass.logic.data.models.messages.text {
         get createdAtString(): string;
         readonly __doNotUseOrImplementIt: games.jass.logic.data.models.messages.UserMessage["__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 TextMessage.$metadata$ {
-        const constructor: abstract new () => TextMessage;
+    namespace TextMessage {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => TextMessage;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player {
@@ -1222,9 +1238,11 @@ 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;
+    namespace JassPlayerLite {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => JassPlayerLite;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player {
@@ -1237,9 +1255,11 @@ 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;
+    namespace UserProfilePayload {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => UserProfilePayload;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.achievements {
@@ -1253,9 +1273,11 @@ 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;
+    namespace Achievements {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => Achievements;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.achievements {
@@ -1271,9 +1293,11 @@ 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;
+    namespace PlayerAchievements {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => PlayerAchievements;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.analytics {
@@ -1285,9 +1309,11 @@ 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;
+    namespace CombinationsAnalytics {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => CombinationsAnalytics;
+        }
     }
     class CombinationAnalytics {
         constructor(type: games.jass.logic.data.models.table.combinations.CombinationType, count: number, acceptedCounts: number);
@@ -1299,9 +1325,11 @@ 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;
+    namespace CombinationAnalytics {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => CombinationAnalytics;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.analytics {
@@ -1320,9 +1348,11 @@ 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;
+    namespace PlayerAnalytics {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => PlayerAnalytics;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.analytics {
@@ -1339,9 +1369,11 @@ 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;
+    namespace PlayerHistoryAnalytics {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => PlayerHistoryAnalytics;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.bids {
@@ -1372,20 +1404,22 @@ export declare namespace games.jass.logic.data.models.player.bids {
         static values(): Array<games.jass.logic.data.models.player.bids.BidType>;
         static valueOf(value: string): games.jass.logic.data.models.player.bids.BidType;
     }
-    /** @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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $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();
+                }
             }
         }
     }
@@ -1403,9 +1437,11 @@ 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;
+    namespace CombinationRecord {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => CombinationRecord;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.points {
@@ -1428,9 +1464,11 @@ 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;
+    namespace 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 $metadata$ {
+            const constructor: abstract new () => PointsDistributeMode;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.state {
@@ -1446,9 +1484,11 @@ export declare namespace games.jass.logic.data.models.player.state {
         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 PlayerLeftResult.$metadata$ {
-        const constructor: abstract new () => PlayerLeftResult;
+    namespace PlayerLeftResult {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => PlayerLeftResult;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.player.state {
@@ -1474,19 +1514,10 @@ export declare namespace games.jass.logic.data.models.player.state {
         static values(): Array<games.jass.logic.data.models.player.state.RoundContractState>;
         static valueOf(value: string): games.jass.logic.data.models.player.state.RoundContractState;
     }
-    /** @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();
-            }
+        namespace $metadata$ {
+            const constructor: abstract new () => RoundContractState;
         }
     }
 }
@@ -1514,19 +1545,21 @@ export declare namespace games.jass.logic.data.models.player.state {
         static values(): Array<games.jass.logic.data.models.player.state.RoundContractType>;
         static valueOf(value: string): games.jass.logic.data.models.player.state.RoundContractType;
     }
-    /** @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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                    get debertzContractTypes(): kotlin.collections.KtList<games.jass.logic.data.models.player.state.RoundContractType>;
+                    private constructor();
+                }
             }
         }
     }
@@ -1551,9 +1584,11 @@ 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;
+    namespace 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 $metadata$ {
+            const constructor: abstract new () => PutHigherTrumpCardMode;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.rules {
@@ -1576,9 +1611,11 @@ 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;
+    namespace 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 $metadata$ {
+            const constructor: abstract new () => PutHigherTrumpCardPartnerMode;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.rules {
@@ -1616,27 +1653,29 @@ export declare namespace games.jass.logic.data.models.rules {
         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;
     }
-    /** @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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $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();
+                }
             }
         }
     }
@@ -1676,9 +1715,11 @@ 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;
+    namespace 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 $metadata$ {
+            const constructor: abstract new () => RulesSetType;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.scenes {
@@ -1718,7 +1759,7 @@ export declare namespace games.jass.logic.data.models.table {
         get gameId(): string;
         get gameDuration(): any/* kotlin.time.Duration */;
         get gameCreatedAt(): any/* kotlin.time.Instant */;
-        get playersConnections(): kotlin.collections.KtList<any/* kotlin.Pair<string, com.logic.data.models.player.PlayerConnectionState> */>;
+        get playersConnections(): kotlin.collections.KtList<kotlin.Pair<string, com.logic.data.models.player.PlayerConnectionState>>;
         get users(): Array<com.logic.data.models.player.GameUserInfo>;
         get isCardDeckExist(): boolean;
         get requireCardDeck(): any/* games.jass.logic.data.models.table.cards.CardDeck */;
@@ -1729,20 +1770,22 @@ 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 JassTable.$metadata$ {
-        const constructor: abstract new () => JassTable;
-    }
     namespace 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 $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $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();
+                }
             }
         }
     }
@@ -1759,9 +1802,11 @@ 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;
+    namespace JassTableLite {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => JassTableLite;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table {
@@ -1776,9 +1821,11 @@ 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;
+    namespace TableLoggerPayload {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => TableLoggerPayload;
+        }
     }
     class PlayerLoggerPayload implements games.raspberry.logger.LoggerPayload {
         constructor(playerId: string, connectionState: Nullable<com.logic.data.models.player.PlayerConnectionState>);
@@ -1790,9 +1837,11 @@ 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;
+    namespace PlayerLoggerPayload {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => PlayerLoggerPayload;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table {
@@ -1805,9 +1854,11 @@ 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;
+    namespace TableStateWithActions {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => TableStateWithActions;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.combinations {
@@ -1818,9 +1869,11 @@ 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;
+    namespace Combination {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => Combination;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.combinations {
@@ -1855,19 +1908,10 @@ export declare namespace games.jass.logic.data.models.table.combinations {
         static values(): Array<games.jass.logic.data.models.table.combinations.CombinationState>;
         static valueOf(value: string): games.jass.logic.data.models.table.combinations.CombinationState;
     }
-    /** @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();
-            }
+        namespace $metadata$ {
+            const constructor: abstract new () => CombinationState;
         }
     }
 }
@@ -1951,23 +1995,25 @@ export declare namespace games.jass.logic.data.models.table.combinations {
         static values(): Array<games.jass.logic.data.models.table.combinations.CombinationType>;
         static valueOf(value: string): games.jass.logic.data.models.table.combinations.CombinationType;
     }
-    /** @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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $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();
+                }
             }
         }
     }
@@ -1983,9 +2029,11 @@ 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;
+    namespace PlayerCombinations {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => PlayerCombinations;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.config {
@@ -2016,19 +2064,10 @@ export declare namespace games.jass.logic.data.models.table.config {
         static values(): Array<games.jass.logic.data.models.table.config.BotIntelligenceLevel>;
         static valueOf(value: string): games.jass.logic.data.models.table.config.BotIntelligenceLevel;
     }
-    /** @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();
-            }
+        namespace $metadata$ {
+            const constructor: abstract new () => BotIntelligenceLevel;
         }
     }
     function getLevel(_this_: games.jass.logic.data.models.table.config.BotIntelligenceLevel): number;
@@ -2053,9 +2092,11 @@ 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;
+    namespace Config {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => Config;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.config {
@@ -2076,9 +2117,11 @@ 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;
+    namespace ConfigLite {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => ConfigLite;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.config {
@@ -2095,19 +2138,21 @@ 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 Options.$metadata$ {
-        const constructor: abstract new () => Options;
-    }
     namespace 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 $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    getServerOptions(isEnableChat?: boolean, isBotsEnabled?: boolean, isEnableChoosePartnerScreen?: boolean): games.jass.logic.data.models.table.config.Options;
+                    private constructor();
+                }
             }
         }
     }
@@ -2139,19 +2184,21 @@ export declare namespace games.jass.logic.data.models.table.config {
         static values(): Array<games.jass.logic.data.models.table.config.PlayersMode>;
         static valueOf(value: string): games.jass.logic.data.models.table.config.PlayersMode;
     }
-    /** @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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                    create(number: number): games.jass.logic.data.models.table.config.PlayersMode;
+                    private constructor();
+                }
             }
         }
     }
@@ -2181,19 +2228,21 @@ export declare namespace games.jass.logic.data.models.table.config {
         static values(): Array<games.jass.logic.data.models.table.config.PointsMode>;
         static valueOf(value: string): games.jass.logic.data.models.table.config.PointsMode;
     }
-    /** @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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                    create(points: number): games.jass.logic.data.models.table.config.PointsMode;
+                    private constructor();
+                }
             }
         }
     }
@@ -2216,9 +2265,11 @@ 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;
+    namespace RoomConfig {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => RoomConfig;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.config {
@@ -2248,9 +2299,11 @@ 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;
+    namespace 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 $metadata$ {
+            const constructor: abstract new () => RoomMode;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.history {
@@ -2263,9 +2316,11 @@ 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;
+    namespace ClientGameHistory {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => ClientGameHistory;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.history {
@@ -2285,19 +2340,21 @@ export declare namespace games.jass.logic.data.models.table.history {
         hashCode(): number;
         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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    initial(gameId: string, createdAt?: any/* kotlin.time.Instant */): games.jass.logic.data.models.table.history.GameHistory;
+                    private constructor();
+                }
             }
         }
     }
@@ -2312,19 +2369,21 @@ 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 GameHistoryMetadata.$metadata$ {
-        const constructor: abstract new () => GameHistoryMetadata;
-    }
     namespace 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 $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    initial(): games.jass.logic.data.models.table.history.GameHistoryMetadata;
+                    private constructor();
+                }
             }
         }
     }
@@ -2346,19 +2405,21 @@ export declare namespace games.jass.logic.data.models.table.history {
         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;
     }
-    /** @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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    initial(roundNumber: number): games.jass.logic.data.models.table.history.RoundHistory;
+                    private constructor();
+                }
             }
         }
     }
@@ -2368,9 +2429,11 @@ export declare namespace games.jass.logic.data.models.table.history {
         protected constructor();
         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;
+    namespace RoundHistoryItem {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => RoundHistoryItem;
+        }
     }
 }
 export declare namespace games.jass.logic.data.models.table.round {
@@ -2388,19 +2451,21 @@ export declare namespace games.jass.logic.data.models.table.round {
         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 Round.$metadata$ {
-        const constructor: abstract new () => Round;
-    }
     namespace 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 $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    initial(): games.jass.logic.data.models.table.round.Round;
+                    private constructor();
+                }
             }
         }
     }
@@ -2452,19 +2517,21 @@ export declare namespace games.jass.logic.domain.interactors.dealer {
         static values(): Array<games.jass.logic.domain.interactors.dealer.DealerStrategy>;
         static valueOf(value: string): 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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    default(): games.jass.logic.domain.interactors.dealer.DealerStrategy;
+                    private constructor();
+                }
             }
         }
     }
@@ -2488,9 +2555,11 @@ export declare namespace games.jass.logic.redux.actions {
         ignoreValidation(): boolean;
         readonly __doNotUseOrImplementIt: com.logic.redux.store.definitions.Action["__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;
+    namespace ClearAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => ClearAction;
+        }
     }
 }
 export declare namespace games.jass.logic.redux.actions.client.from {
@@ -2501,9 +2570,11 @@ 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;
+    namespace FromClientAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => FromClientAction;
+        }
     }
 }
 export declare namespace games.jass.logic.redux.actions.client.to {
@@ -2522,20 +2593,22 @@ export declare namespace games.jass.logic.redux.actions.client.to {
         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;
     }
-    /** @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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $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();
+                }
             }
         }
     }
@@ -2558,19 +2631,10 @@ export declare namespace games.jass.logic.redux.actions.client.to {
         static values(): Array<games.jass.logic.redux.actions.client.to.ActionDeliveryType>;
         static valueOf(value: string): games.jass.logic.redux.actions.client.to.ActionDeliveryType;
     }
-    /** @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();
-            }
+        namespace $metadata$ {
+            const constructor: abstract new () => ActionDeliveryType;
         }
     }
 }
@@ -2581,9 +2645,11 @@ 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;
+    namespace ToClientAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => ToClientAction;
+        }
     }
 }
 export declare namespace games.jass.logic.redux.actions.game {
@@ -2592,9 +2658,11 @@ 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 GameAction.$metadata$ {
-        const constructor: abstract new () => GameAction;
+    namespace 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 $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);
@@ -2613,9 +2681,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;
     }
-    /** @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;
+    namespace RoundStartedAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $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>>, gameWinners: Nullable<Array<string>>, leftPermanentlyPlayers: 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);
@@ -2637,9 +2707,11 @@ 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>>, leftPermanentlyPlayers?: 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;
+    namespace RoundEndedAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => RoundEndedAction;
+        }
     }
     class PartyRestartedAction implements com.logic.redux.store.definitions.Action {
         constructor(id: string, roundNumber: number);
@@ -2652,9 +2724,11 @@ 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;
+    namespace PartyRestartedAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => PartyRestartedAction;
+        }
     }
 }
 export declare namespace games.jass.logic.redux.actions.mechanic {
@@ -2678,9 +2752,11 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         get isEnableChoosePartnerScreen(): 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 RevengeRoomTransition.$metadata$ {
-        const constructor: abstract new () => RevengeRoomTransition;
+    namespace RevengeRoomTransition {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => RevengeRoomTransition;
+        }
     }
     class GameToRoomTransition implements games.jass.logic.redux.actions.mechanic.GameTransition {
         constructor(roomId: string, playerIds: kotlin.collections.KtList<string>, previousPlayers: kotlin.collections.KtList<string>);
@@ -2695,9 +2771,11 @@ 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;
+    namespace GameToRoomTransition {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => GameToRoomTransition;
+        }
     }
 }
 export declare namespace games.jass.logic.redux.actions.mechanic {
@@ -2707,9 +2785,11 @@ 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;
+    namespace 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 $metadata$ {
+            const constructor: abstract new () => MechanicAction;
+        }
     }
     interface FirstMechanicAction extends com.logic.redux.store.definitions.Action, com.logic.redux.actions.IgnoreBufferForAction, games.jass.logic.redux.actions.mechanic.PlayerOrderChangeMechanicAction {
         readonly id: string;
@@ -2744,9 +2824,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"];
     }
-    /** @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;
+    namespace StartGameMechanicAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $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>);
@@ -2759,9 +2841,11 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         equals(other: Nullable<any>): boolean;
         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 StartNewGameMechanicAction.$metadata$ {
-        const constructor: abstract new () => StartNewGameMechanicAction;
+    namespace StartNewGameMechanicAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => StartNewGameMechanicAction;
+        }
     }
     class ContinueGameMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor implements games.jass.logic.redux.actions.mechanic.FirstMechanicAction, com.logic.redux.actions.validation.NotValidateIfGameFinished {
         constructor(table: games.jass.logic.data.models.table.JassTable, reason: any/* com.logic.data.models.ContinueGameReason */, payload?: Nullable<games.jass.logic.redux.AppStatePayload>, aid?: Nullable<string>);
@@ -2783,9 +2867,11 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         ignoreValidation(): boolean;
         readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.FirstMechanicAction["__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 ContinueGameMechanicAction.$metadata$ {
-        const constructor: abstract new () => ContinueGameMechanicAction;
+    namespace ContinueGameMechanicAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => ContinueGameMechanicAction;
+        }
     }
     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>);
@@ -2804,20 +2890,22 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         ignoreValidation(): 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"];
     }
-    /** @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 {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $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();
+                }
             }
         }
     }
@@ -2835,9 +2923,11 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         ignoreValidation(): 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;
+    namespace FinishGameMechanicAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => FinishGameMechanicAction;
+        }
     }
     interface NavigationMechanicAction extends com.logic.redux.store.definitions.Action {
         readonly sceneId: string;
@@ -2863,9 +2953,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.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.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;
+    namespace SceneMechanicAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => SceneMechanicAction;
+        }
     }
     interface TerminatedAction extends com.logic.redux.store.definitions.Action {
         readonly reason: com.logic.data.models.TerminationGameReason;
@@ -2889,9 +2981,11 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.store.definitions.Action["__doNotUseOrImplementIt"] & com.logic.redux.actions.BufferedAction["__doNotUseOrImplementIt"] & games.jass.logic.redux.actions.mechanic.PlayerOrderChangeMechanicAction["__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 TeamsDataMechanicAction.$metadata$ {
-        const constructor: abstract new () => TeamsDataMechanicAction;
+    namespace TeamsDataMechanicAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => TeamsDataMechanicAction;
+        }
     }
     class PlayerConnectionChangedMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor implements com.logic.redux.actions.validation.NotValidateIfGameFinished, com.logic.redux.actions.validation.NotValidateIfGameNotCreated {
         constructor(playerId: string, state: com.logic.data.models.player.PlayerConnectionState, previousState: com.logic.data.models.player.PlayerConnectionState, causeState?: Nullable<com.logic.data.models.player.PlayerConnectionState>, isNoneActivePlayers?: boolean, reconnectUntilTime?: Nullable<string>, aid?: Nullable<string>);
@@ -2914,9 +3008,11 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameFinished["__doNotUseOrImplementIt"] & com.logic.redux.actions.validation.NotValidateIfGameNotCreated["__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;
+    namespace PlayerConnectionChangedMechanicAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => PlayerConnectionChangedMechanicAction;
+        }
     }
     class MessageMechanicAction extends games.jass.logic.redux.actions.mechanic.MechanicAction.$metadata$.constructor implements com.logic.redux.actions.IgnoreBufferForAction {
         constructor(message: games.jass.logic.data.models.messages.Message, aid?: Nullable<string>);
@@ -2929,9 +3025,11 @@ export declare namespace games.jass.logic.redux.actions.mechanic {
         get actionTag(): string;
         readonly __doNotUseOrImplementIt: games.jass.logic.redux.actions.mechanic.MechanicAction["__doNotUseOrImplementIt"] & com.logic.redux.actions.IgnoreBufferForAction["__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 MessageMechanicAction.$metadata$ {
-        const constructor: abstract new () => MessageMechanicAction;
+    namespace MessageMechanicAction {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => MessageMechanicAction;
+        }
     }
 }
 export declare interface GameHelper {
@@ -3012,9 +3110,11 @@ 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;
+    namespace EngineHelpersFactory {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => EngineHelpersFactory;
+        }
     }
 }
 export declare namespace models {
@@ -3027,9 +3127,11 @@ export declare namespace 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 BotRatingRange.$metadata$ {
-        const constructor: abstract new () => BotRatingRange;
+    namespace BotRatingRange {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => BotRatingRange;
+        }
     }
 }
 export declare namespace games.jass.logic.client.data.models.config {
@@ -3060,19 +3162,10 @@ export declare namespace games.jass.logic.client.data.models.config {
         static values(): Array<games.jass.logic.client.data.models.config.GameType>;
         static valueOf(value: string): games.jass.logic.client.data.models.config.GameType;
     }
-    /** @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();
-            }
+        namespace $metadata$ {
+            const constructor: abstract new () => GameType;
         }
     }
 }
@@ -3091,19 +3184,21 @@ export declare namespace games.jass.logic.client.data.models.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 GameClientConfig.$metadata$ {
-        const constructor: abstract new () => GameClientConfig;
-    }
     namespace 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 $metadata$ {
+            const constructor: abstract new () => 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();
+        namespace 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 $metadata$ {
+                abstract class constructor {
+                    getClientEngineTestMode(): games.jass.logic.client.data.models.config.GameClientConfig;
+                    private constructor();
+                }
             }
         }
     }
@@ -3123,9 +3218,11 @@ export declare namespace games.jass.logic.client.data.models.vm {
         toString(): string;
         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;
+    namespace 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 $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>);
@@ -3141,9 +3238,11 @@ 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;
+    namespace RoundEndedHistoryViewModel {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => RoundEndedHistoryViewModel;
+        }
     }
 }
 export declare namespace games.jass.logic.client.domain.mechanic {