@acidify/core 0.3.1-beta.1 → 0.3.1-beta.2

package/dist/acidify-acidify-core.d.ts

@@ -6,19 +6,8 @@ export declare interface KtList<E> /* extends Collection<E> */ {
         readonly "kotlin.collections.KtList": unique symbol;
     };
 }
-export declare abstract class KtList<E> {
-    static readonly getInstance: () => typeof KtList.$metadata$.type;
-    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 */
-export declare namespace KtList.$metadata$ {
-    abstract class type<E> extends KtSingleton<constructor>() {
-        private constructor();
-    }
-    abstract class constructor {
-        fromJsArray<E>(array: ReadonlyArray<E>): KtList<E>;
-        private constructor();
-    }
+export declare namespace KtList {
+    function fromJsArray<E>(array: ReadonlyArray<E>): KtList<E>;
 }
 export declare interface KtMap<K, V> {
     asJsReadonlyMapView(): ReadonlyMap<K, V>;
@@ -26,19 +15,8 @@ export declare interface KtMap<K, V> {
         readonly "kotlin.collections.KtMap": unique symbol;
     };
 }
-export declare abstract class KtMap<K, V> {
-    static readonly getInstance: () => typeof KtMap.$metadata$.type;
-    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 */
-export declare namespace KtMap.$metadata$ {
-    abstract class type<K, V> extends KtSingleton<constructor>() {
-        private constructor();
-    }
-    abstract class constructor {
-        fromJsMap<K, V>(map: ReadonlyMap<K, V>): KtMap<K, V>;
-        private constructor();
-    }
+export declare namespace KtMap {
+    function fromJsMap<K, V>(map: ReadonlyMap<K, V>): KtMap<K, V>;
 }
 /** @deprecated  */
 export declare const initHook: { get(): any; };
@@ -62,36 +40,32 @@ export declare class AppInfo {
     toJson(): string;
     static fromJson(json: string): AppInfo;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace AppInfo.$metadata$ {
-    const constructor: abstract new () => AppInfo;
-}
 export declare namespace AppInfo {
-    abstract class Bundled {
-        static readonly getInstance: () => typeof Bundled.$metadata$.type;
+    /** @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 () => AppInfo;
+    }
+    abstract class Bundled extends KtSingleton<Bundled.$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 Bundled.$metadata$ {
-        abstract class type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class constructor {
-            get Linux(): AppInfo;
-            private constructor();
+    namespace Bundled {
+        /** @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 Linux(): AppInfo;
+                private constructor();
+            }
         }
     }
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class 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 {
+                private constructor();
+            }
         }
     }
 }
@@ -124,22 +98,20 @@ export declare class SessionStore {
     static empty(): SessionStore;
     static fromJson(json: string): SessionStore;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace SessionStore.$metadata$ {
-    const constructor: abstract new () => SessionStore;
-}
 export declare namespace SessionStore {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @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 () => SessionStore;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class 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 {
+                private constructor();
+            }
         }
     }
 }
@@ -149,9 +121,11 @@ export declare class SignResult {
     get token(): Int8Array;
     get extra(): Int8Array;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace SignResult.$metadata$ {
-    const constructor: abstract new () => SignResult;
+export declare namespace SignResult {
+    /** @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 () => SignResult;
+    }
 }
 export declare class BotFriend /* extends AbstractEntity<BotFriendData> */ {
     private constructor();
@@ -167,9 +141,11 @@ export declare class BotFriend /* extends AbstractEntity<BotFriendData> */ {
     get categoryName(): string;
     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 */
-export declare namespace BotFriend.$metadata$ {
-    const constructor: abstract new () => BotFriend;
+export declare namespace BotFriend {
+    /** @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 () => BotFriend;
+    }
 }
 export declare class BotGroup /* extends AbstractEntity<BotGroupData> */ {
     private constructor();
@@ -177,13 +153,13 @@ export declare class BotGroup /* extends AbstractEntity<BotGroupData> */ {
     get name(): string;
     get memberCount(): number;
     get capacity(): number;
-    getMembers$default(forceUpdate: boolean | undefined, $completion: any/* Continuation<KtList<BotGroupMember>> */): any;
-    getMember$default(uin: bigint, forceUpdate: boolean | undefined, $completion: any/* Continuation<Nullable<BotGroupMember>> */): Nullable<any>;
     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 */
-export declare namespace BotGroup.$metadata$ {
-    const constructor: abstract new () => BotGroup;
+export declare namespace BotGroup {
+    /** @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 () => BotGroup;
+    }
 }
 export declare class BotGroupMember /* extends AbstractEntity<BotGroupMemberData> */ {
     private constructor();
@@ -200,9 +176,11 @@ export declare class BotGroupMember /* extends AbstractEntity<BotGroupMemberData
     get role(): GroupMemberRole;
     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 */
-export declare namespace BotGroupMember.$metadata$ {
-    const constructor: abstract new () => BotGroupMember;
+export declare namespace BotGroupMember {
+    /** @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 () => BotGroupMember;
+    }
 }
 export declare interface AcidifyEvent {
     readonly __doNotUseOrImplementIt: {
@@ -214,9 +192,11 @@ export declare class BotOfflineEvent implements AcidifyEvent {
     get reason(): string;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace BotOfflineEvent.$metadata$ {
-    const constructor: abstract new () => BotOfflineEvent;
+export declare namespace BotOfflineEvent {
+    /** @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 () => BotOfflineEvent;
+    }
 }
 export declare class FriendFileUploadEvent implements AcidifyEvent {
     constructor(userUin: bigint, userUid: string, fileId: string, fileName: string, fileSize: bigint, fileHash: string, isSelf: boolean);
@@ -229,9 +209,11 @@ export declare class FriendFileUploadEvent implements AcidifyEvent {
     get isSelf(): boolean;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace FriendFileUploadEvent.$metadata$ {
-    const constructor: abstract new () => FriendFileUploadEvent;
+export declare namespace FriendFileUploadEvent {
+    /** @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 () => FriendFileUploadEvent;
+    }
 }
 export declare class FriendNudgeEvent implements AcidifyEvent {
     constructor(userUin: bigint, userUid: string, isSelfSend: boolean, isSelfReceive: boolean, displayAction: string, displaySuffix: string, displayActionImgUrl: string);
@@ -244,9 +226,11 @@ export declare class FriendNudgeEvent implements AcidifyEvent {
     get displayActionImgUrl(): string;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace FriendNudgeEvent.$metadata$ {
-    const constructor: abstract new () => FriendNudgeEvent;
+export declare namespace FriendNudgeEvent {
+    /** @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 () => FriendNudgeEvent;
+    }
 }
 export declare class FriendRequestEvent implements AcidifyEvent {
     constructor(initiatorUin: bigint, initiatorUid: string, comment: string, via: string);
@@ -256,9 +240,11 @@ export declare class FriendRequestEvent implements AcidifyEvent {
     get via(): string;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace FriendRequestEvent.$metadata$ {
-    const constructor: abstract new () => FriendRequestEvent;
+export declare namespace FriendRequestEvent {
+    /** @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 () => FriendRequestEvent;
+    }
 }
 export declare class GroupAdminChangeEvent implements AcidifyEvent {
     constructor(groupUin: bigint, userUin: bigint, userUid: string, isSet: boolean);
@@ -268,9 +254,11 @@ export declare class GroupAdminChangeEvent implements AcidifyEvent {
     get isSet(): boolean;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupAdminChangeEvent.$metadata$ {
-    const constructor: abstract new () => GroupAdminChangeEvent;
+export declare namespace GroupAdminChangeEvent {
+    /** @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 () => GroupAdminChangeEvent;
+    }
 }
 export declare class GroupEssenceMessageChangeEvent implements AcidifyEvent {
     constructor(groupUin: bigint, messageSeq: bigint, isSet: boolean);
@@ -279,9 +267,11 @@ export declare class GroupEssenceMessageChangeEvent implements AcidifyEvent {
     get isSet(): boolean;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupEssenceMessageChangeEvent.$metadata$ {
-    const constructor: abstract new () => GroupEssenceMessageChangeEvent;
+export declare namespace GroupEssenceMessageChangeEvent {
+    /** @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 () => GroupEssenceMessageChangeEvent;
+    }
 }
 export declare class GroupFileUploadEvent implements AcidifyEvent {
     constructor(groupUin: bigint, userUin: bigint, userUid: string, fileId: string, fileName: string, fileSize: bigint);
@@ -293,9 +283,11 @@ export declare class GroupFileUploadEvent implements AcidifyEvent {
     get fileSize(): bigint;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupFileUploadEvent.$metadata$ {
-    const constructor: abstract new () => GroupFileUploadEvent;
+export declare namespace GroupFileUploadEvent {
+    /** @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 () => GroupFileUploadEvent;
+    }
 }
 export declare class GroupInvitationEvent implements AcidifyEvent {
     constructor(groupUin: bigint, invitationSeq: bigint, initiatorUin: bigint, initiatorUid: string);
@@ -305,9 +297,11 @@ export declare class GroupInvitationEvent implements AcidifyEvent {
     get initiatorUid(): string;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupInvitationEvent.$metadata$ {
-    const constructor: abstract new () => GroupInvitationEvent;
+export declare namespace GroupInvitationEvent {
+    /** @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 () => GroupInvitationEvent;
+    }
 }
 export declare class GroupInvitedJoinRequestEvent implements AcidifyEvent {
     constructor(groupUin: bigint, notificationSeq: bigint, initiatorUin: bigint, initiatorUid: string, targetUserUin: bigint, targetUserUid: string);
@@ -319,9 +313,11 @@ export declare class GroupInvitedJoinRequestEvent implements AcidifyEvent {
     get targetUserUid(): string;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupInvitedJoinRequestEvent.$metadata$ {
-    const constructor: abstract new () => GroupInvitedJoinRequestEvent;
+export declare namespace GroupInvitedJoinRequestEvent {
+    /** @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 () => GroupInvitedJoinRequestEvent;
+    }
 }
 export declare class GroupJoinRequestEvent implements AcidifyEvent {
     constructor(groupUin: bigint, notificationSeq: bigint, isFiltered: boolean, initiatorUin: bigint, initiatorUid: string, comment: string);
@@ -333,9 +329,11 @@ export declare class GroupJoinRequestEvent implements AcidifyEvent {
     get comment(): string;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupJoinRequestEvent.$metadata$ {
-    const constructor: abstract new () => GroupJoinRequestEvent;
+export declare namespace GroupJoinRequestEvent {
+    /** @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 () => GroupJoinRequestEvent;
+    }
 }
 export declare class GroupMemberDecreaseEvent implements AcidifyEvent {
     constructor(groupUin: bigint, userUin: bigint, userUid: string, operatorUin: Nullable<bigint>, operatorUid: Nullable<string>);
@@ -346,9 +344,11 @@ export declare class GroupMemberDecreaseEvent implements AcidifyEvent {
     get operatorUid(): Nullable<string>;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupMemberDecreaseEvent.$metadata$ {
-    const constructor: abstract new () => GroupMemberDecreaseEvent;
+export declare namespace GroupMemberDecreaseEvent {
+    /** @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 () => GroupMemberDecreaseEvent;
+    }
 }
 export declare class GroupMemberIncreaseEvent implements AcidifyEvent {
     constructor(groupUin: bigint, userUin: bigint, userUid: string, operatorUin: Nullable<bigint>, operatorUid: Nullable<string>, invitorUin: Nullable<bigint>, invitorUid: Nullable<string>);
@@ -361,9 +361,11 @@ export declare class GroupMemberIncreaseEvent implements AcidifyEvent {
     get invitorUid(): Nullable<string>;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupMemberIncreaseEvent.$metadata$ {
-    const constructor: abstract new () => GroupMemberIncreaseEvent;
+export declare namespace GroupMemberIncreaseEvent {
+    /** @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 () => GroupMemberIncreaseEvent;
+    }
 }
 export declare class GroupMessageReactionEvent implements AcidifyEvent {
     constructor(groupUin: bigint, userUin: bigint, userUid: string, messageSeq: bigint, faceId: string, isAdd: boolean);
@@ -375,9 +377,11 @@ export declare class GroupMessageReactionEvent implements AcidifyEvent {
     get isAdd(): boolean;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupMessageReactionEvent.$metadata$ {
-    const constructor: abstract new () => GroupMessageReactionEvent;
+export declare namespace GroupMessageReactionEvent {
+    /** @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 () => GroupMessageReactionEvent;
+    }
 }
 export declare class GroupMuteEvent implements AcidifyEvent {
     constructor(groupUin: bigint, userUin: bigint, userUid: string, operatorUin: bigint, operatorUid: string, duration: number);
@@ -389,9 +393,11 @@ export declare class GroupMuteEvent implements AcidifyEvent {
     get duration(): number;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupMuteEvent.$metadata$ {
-    const constructor: abstract new () => GroupMuteEvent;
+export declare namespace GroupMuteEvent {
+    /** @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 () => GroupMuteEvent;
+    }
 }
 export declare class GroupNameChangeEvent implements AcidifyEvent {
     constructor(groupUin: bigint, newGroupName: string, operatorUin: bigint, operatorUid: string);
@@ -401,9 +407,11 @@ export declare class GroupNameChangeEvent implements AcidifyEvent {
     get operatorUid(): string;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupNameChangeEvent.$metadata$ {
-    const constructor: abstract new () => GroupNameChangeEvent;
+export declare namespace GroupNameChangeEvent {
+    /** @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 () => GroupNameChangeEvent;
+    }
 }
 export declare class GroupNudgeEvent implements AcidifyEvent {
     constructor(groupUin: bigint, senderUin: bigint, senderUid: string, receiverUin: bigint, receiverUid: string, displayAction: string, displaySuffix: string, displayActionImgUrl: string);
@@ -417,9 +425,11 @@ export declare class GroupNudgeEvent implements AcidifyEvent {
     get displayActionImgUrl(): string;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupNudgeEvent.$metadata$ {
-    const constructor: abstract new () => GroupNudgeEvent;
+export declare namespace GroupNudgeEvent {
+    /** @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 () => GroupNudgeEvent;
+    }
 }
 export declare class GroupWholeMuteEvent implements AcidifyEvent {
     constructor(groupUin: bigint, operatorUin: bigint, operatorUid: string, isMute: boolean);
@@ -429,9 +439,11 @@ export declare class GroupWholeMuteEvent implements AcidifyEvent {
     get isMute(): boolean;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupWholeMuteEvent.$metadata$ {
-    const constructor: abstract new () => GroupWholeMuteEvent;
+export declare namespace GroupWholeMuteEvent {
+    /** @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 () => GroupWholeMuteEvent;
+    }
 }
 export declare class MessageRecallEvent implements AcidifyEvent {
     constructor(scene: MessageScene, peerUin: bigint, messageSeq: bigint, senderUin: bigint, senderUid: string, operatorUin: bigint, operatorUid: string, displaySuffix: string);
@@ -445,18 +457,22 @@ export declare class MessageRecallEvent implements AcidifyEvent {
     get displaySuffix(): string;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace MessageRecallEvent.$metadata$ {
-    const constructor: abstract new () => MessageRecallEvent;
+export declare namespace MessageRecallEvent {
+    /** @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 () => MessageRecallEvent;
+    }
 }
 export declare class MessageReceiveEvent implements AcidifyEvent {
     constructor(message: BotIncomingMessage);
     get message(): BotIncomingMessage;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace MessageReceiveEvent.$metadata$ {
-    const constructor: abstract new () => MessageReceiveEvent;
+export declare namespace MessageReceiveEvent {
+    /** @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 () => MessageReceiveEvent;
+    }
 }
 export declare class QRCodeGeneratedEvent implements AcidifyEvent {
     constructor(url: string, png: Int8Array);
@@ -464,44 +480,54 @@ export declare class QRCodeGeneratedEvent implements AcidifyEvent {
     get png(): Int8Array;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace QRCodeGeneratedEvent.$metadata$ {
-    const constructor: abstract new () => QRCodeGeneratedEvent;
+export declare namespace QRCodeGeneratedEvent {
+    /** @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 () => QRCodeGeneratedEvent;
+    }
 }
 export declare class QRCodeStateQueryEvent implements AcidifyEvent {
     constructor(state: QRCodeState);
     get state(): QRCodeState;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace QRCodeStateQueryEvent.$metadata$ {
-    const constructor: abstract new () => QRCodeStateQueryEvent;
+export declare namespace QRCodeStateQueryEvent {
+    /** @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 () => QRCodeStateQueryEvent;
+    }
 }
 export declare class SessionStoreUpdatedEvent implements AcidifyEvent {
     constructor(sessionStore: SessionStore);
     get sessionStore(): SessionStore;
     readonly __doNotUseOrImplementIt: AcidifyEvent["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace SessionStoreUpdatedEvent.$metadata$ {
-    const constructor: abstract new () => SessionStoreUpdatedEvent;
+export declare namespace SessionStoreUpdatedEvent {
+    /** @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 () => SessionStoreUpdatedEvent;
+    }
 }
 export declare class BotOnlineException extends /* Exception */ Error {
     constructor(systemMsg: string);
     get systemMsg(): string;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace BotOnlineException.$metadata$ {
-    const constructor: abstract new () => BotOnlineException;
+export declare namespace BotOnlineException {
+    /** @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 () => BotOnlineException;
+    }
 }
 export declare class MessageSendException extends /* Exception */ Error {
     constructor(resultCode: number, errorMessage: string);
     get resultCode(): number;
     get errorMessage(): string;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace MessageSendException.$metadata$ {
-    const constructor: abstract new () => MessageSendException;
+export declare namespace MessageSendException {
+    /** @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 () => MessageSendException;
+    }
 }
 export declare class OidbException extends /* Exception */ Error {
     constructor(oidbCommand: number, oidbService: number, oidbResult: number, oidbErrorMsg: string);
@@ -510,9 +536,11 @@ export declare class OidbException extends /* Exception */ Error {
     get oidbResult(): number;
     get oidbErrorMsg(): string;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace OidbException.$metadata$ {
-    const constructor: abstract new () => OidbException;
+export declare namespace OidbException {
+    /** @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 () => OidbException;
+    }
 }
 export declare class ServiceException extends /* Exception */ Error {
     constructor(cmd: string, retCode: number, extra: string);
@@ -520,17 +548,21 @@ export declare class ServiceException extends /* Exception */ Error {
     get retCode(): number;
     get extra(): string;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace ServiceException.$metadata$ {
-    const constructor: abstract new () => ServiceException;
+export declare namespace ServiceException {
+    /** @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 () => ServiceException;
+    }
 }
 export declare class WebApiException extends /* Exception */ Error {
     constructor(msg: string, statusCode: number);
     get statusCode(): number;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace WebApiException.$metadata$ {
-    const constructor: abstract new () => WebApiException;
+export declare namespace WebApiException {
+    /** @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 () => WebApiException;
+    }
 }
 export declare class WtLoginException extends /* Exception */ Error {
     constructor(code: number, tag: string, msg: string);
@@ -538,9 +570,11 @@ export declare class WtLoginException extends /* Exception */ Error {
     get tag(): string;
     get msg(): string;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace WtLoginException.$metadata$ {
-    const constructor: abstract new () => WtLoginException;
+export declare namespace WtLoginException {
+    /** @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 () => WtLoginException;
+    }
 }
 export declare interface LogHandler {
     handleLog(level: LogLevel, tag: string, message: string, throwable: Nullable<Error>): void;
@@ -575,39 +609,45 @@ export declare abstract class LogLevel {
     static values(): Array<LogLevel>;
     static valueOf(value: string): LogLevel;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace LogLevel.$metadata$ {
-    const constructor: abstract new () => LogLevel;
+export declare namespace LogLevel {
+    /** @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 () => LogLevel;
+    }
 }
 export declare function shortenPackageName(tag: string): string;
 export declare abstract class NopLogHandler {
     static readonly getInstance: () => typeof NopLogHandler.$metadata$.type;
     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 */
-export declare namespace NopLogHandler.$metadata$ {
-    abstract class type extends KtSingleton<constructor>() {
-        private constructor();
-    }
-    abstract class constructor implements LogHandler {
-        handleLog(level: LogLevel, tag: string, message: string, throwable: Nullable<Error>): void;
-        readonly __doNotUseOrImplementIt: LogHandler["__doNotUseOrImplementIt"];
-        private constructor();
+export declare namespace NopLogHandler {
+    /** @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 type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor implements LogHandler {
+            handleLog(level: LogLevel, tag: string, message: string, throwable: Nullable<Error>): void;
+            readonly __doNotUseOrImplementIt: LogHandler["__doNotUseOrImplementIt"];
+            private constructor();
+        }
     }
 }
 export declare abstract class SimpleLogHandler {
     static readonly getInstance: () => typeof SimpleLogHandler.$metadata$.type;
     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 */
-export declare namespace SimpleLogHandler.$metadata$ {
-    abstract class type extends KtSingleton<constructor>() {
-        private constructor();
-    }
-    abstract class constructor implements LogHandler {
-        handleLog(level: LogLevel, tag: string, message: string, throwable: Nullable<Error>): void;
-        readonly __doNotUseOrImplementIt: LogHandler["__doNotUseOrImplementIt"];
-        private constructor();
+export declare namespace SimpleLogHandler {
+    /** @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 type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor implements LogHandler {
+            handleLog(level: LogLevel, tag: string, message: string, throwable: Nullable<Error>): void;
+            readonly __doNotUseOrImplementIt: LogHandler["__doNotUseOrImplementIt"];
+            private constructor();
+        }
     }
 }
 export declare class BotEssenceMessage {
@@ -622,22 +662,20 @@ export declare class BotEssenceMessage {
     get operationTime(): bigint;
     get segments(): KtList<BotEssenceSegment>;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace BotEssenceMessage.$metadata$ {
-    const constructor: abstract new () => BotEssenceMessage;
-}
 export declare namespace BotEssenceMessage {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @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 () => BotEssenceMessage;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class 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 {
+                private constructor();
+            }
         }
     }
 }
@@ -646,18 +684,20 @@ export declare class BotEssenceMessageResult {
     get messages(): KtList<BotEssenceMessage>;
     get isEnd(): boolean;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace BotEssenceMessageResult.$metadata$ {
-    const constructor: abstract new () => BotEssenceMessageResult;
+export declare namespace BotEssenceMessageResult {
+    /** @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 () => BotEssenceMessageResult;
+    }
 }
 export declare abstract class BotEssenceSegment {
     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 */
-export declare namespace BotEssenceSegment.$metadata$ {
-    const constructor: abstract new () => BotEssenceSegment;
-}
 export declare namespace BotEssenceSegment {
+    /** @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 () => BotEssenceSegment;
+    }
     class Text extends BotEssenceSegment.$metadata$.constructor {
         constructor(text: string);
         get text(): string;
@@ -666,9 +706,11 @@ export declare namespace BotEssenceSegment {
         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 Text.$metadata$ {
-        const constructor: abstract new () => Text;
+    namespace Text {
+        /** @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 () => Text;
+        }
     }
     class Face extends BotEssenceSegment.$metadata$.constructor {
         constructor(faceId: number);
@@ -678,9 +720,11 @@ export declare namespace BotEssenceSegment {
         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 Face.$metadata$ {
-        const constructor: abstract new () => Face;
+    namespace Face {
+        /** @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 () => Face;
+        }
     }
     class Image extends BotEssenceSegment.$metadata$.constructor {
         constructor(imageUrl: string);
@@ -690,9 +734,11 @@ export declare namespace BotEssenceSegment {
         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 Image.$metadata$ {
-        const constructor: abstract new () => Image;
+    namespace Image {
+        /** @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 () => Image;
+        }
     }
     class Video extends BotEssenceSegment.$metadata$.constructor {
         constructor(thumbnailUrl: string);
@@ -702,9 +748,11 @@ export declare namespace BotEssenceSegment {
         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 Video.$metadata$ {
-        const constructor: abstract new () => Video;
+    namespace Video {
+        /** @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 () => Video;
+        }
     }
 }
 export declare class BotForwardedMessage {
@@ -714,22 +762,20 @@ export declare class BotForwardedMessage {
     get timestamp(): bigint;
     get segments(): KtList<BotIncomingSegment>;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace BotForwardedMessage.$metadata$ {
-    const constructor: abstract new () => BotForwardedMessage;
-}
 export declare namespace BotForwardedMessage {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @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 () => BotForwardedMessage;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class 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 {
+                private constructor();
+            }
         }
     }
 }
@@ -738,9 +784,11 @@ export declare class BotHistoryMessages {
     get messages(): KtList<BotIncomingMessage>;
     get nextStartSequence(): Nullable<bigint>;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace BotHistoryMessages.$metadata$ {
-    const constructor: abstract new () => BotHistoryMessages;
+export declare namespace BotHistoryMessages {
+    /** @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 () => BotHistoryMessages;
+    }
 }
 export declare class BotIncomingMessage {
     constructor(scene: MessageScene, peerUin: bigint, peerUid: string, sequence: bigint, timestamp: bigint, senderUin: bigint, senderUid: string, clientSequence: bigint, random: number, messageUid: bigint);
@@ -758,51 +806,53 @@ export declare class BotIncomingMessage {
     get extraInfo(): Nullable<BotIncomingMessage.ExtraInfo>;
     set extraInfo(value: Nullable<BotIncomingMessage.ExtraInfo>);
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace BotIncomingMessage.$metadata$ {
-    const constructor: abstract new () => BotIncomingMessage;
-}
 export declare namespace BotIncomingMessage {
+    /** @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 () => BotIncomingMessage;
+    }
     class ExtraInfo {
         constructor(nick: string, groupCard: string, specialTitle: string);
         get nick(): string;
         get groupCard(): string;
         get specialTitle(): 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 ExtraInfo.$metadata$ {
-        const constructor: abstract new () => ExtraInfo;
+    namespace ExtraInfo {
+        /** @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 () => ExtraInfo;
+        }
     }
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class 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 {
+                private constructor();
+            }
         }
     }
 }
 export declare abstract class BotIncomingSegment {
     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 */
-export declare namespace BotIncomingSegment.$metadata$ {
-    const constructor: abstract new () => BotIncomingSegment;
-}
 export declare namespace BotIncomingSegment {
+    /** @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 () => BotIncomingSegment;
+    }
     class Text extends BotIncomingSegment.$metadata$.constructor {
         constructor(text: string);
         get text(): string;
         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 Text.$metadata$ {
-        const constructor: abstract new () => Text;
+    namespace Text {
+        /** @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 () => Text;
+        }
     }
     class Mention extends BotIncomingSegment.$metadata$.constructor {
         constructor(uin: Nullable<bigint> | undefined, name: string);
@@ -810,9 +860,11 @@ export declare namespace BotIncomingSegment {
         get name(): string;
         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 Mention.$metadata$ {
-        const constructor: abstract new () => Mention;
+    namespace Mention {
+        /** @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 () => Mention;
+        }
     }
     class Face extends BotIncomingSegment.$metadata$.constructor {
         constructor(faceId: number, summary: string, isLarge: boolean);
@@ -821,18 +873,22 @@ export declare namespace BotIncomingSegment {
         get isLarge(): boolean;
         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 Face.$metadata$ {
-        const constructor: abstract new () => Face;
+    namespace Face {
+        /** @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 () => Face;
+        }
     }
     class Reply extends BotIncomingSegment.$metadata$.constructor {
         constructor(sequence: bigint);
         get sequence(): bigint;
         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 Reply.$metadata$ {
-        const constructor: abstract new () => Reply;
+    namespace Reply {
+        /** @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 () => Reply;
+        }
     }
     class Image extends BotIncomingSegment.$metadata$.constructor {
         constructor(fileId: string, width: number, height: number, subType: ImageSubType, summary: string);
@@ -843,9 +899,11 @@ export declare namespace BotIncomingSegment {
         get summary(): string;
         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 Image.$metadata$ {
-        const constructor: abstract new () => Image;
+    namespace Image {
+        /** @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 () => Image;
+        }
     }
     class Record extends BotIncomingSegment.$metadata$.constructor {
         constructor(fileId: string, duration: number);
@@ -853,9 +911,11 @@ export declare namespace BotIncomingSegment {
         get duration(): number;
         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 Record.$metadata$ {
-        const constructor: abstract new () => Record;
+    namespace Record {
+        /** @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 () => Record;
+        }
     }
     class Video extends BotIncomingSegment.$metadata$.constructor {
         constructor(fileId: string, duration: number, width: number, height: number);
@@ -865,9 +925,11 @@ export declare namespace BotIncomingSegment {
         get height(): number;
         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 Video.$metadata$ {
-        const constructor: abstract new () => Video;
+    namespace Video {
+        /** @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 () => Video;
+        }
     }
     class File extends BotIncomingSegment.$metadata$.constructor {
         constructor(fileId: string, fileName: string, fileSize: bigint, fileHash?: Nullable<string>);
@@ -877,18 +939,22 @@ export declare namespace BotIncomingSegment {
         get fileHash(): Nullable<string>;
         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 File.$metadata$ {
-        const constructor: abstract new () => File;
+    namespace File {
+        /** @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 () => File;
+        }
     }
     class Forward extends BotIncomingSegment.$metadata$.constructor {
         constructor(resId: string);
         get resId(): string;
         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 Forward.$metadata$ {
-        const constructor: abstract new () => Forward;
+    namespace Forward {
+        /** @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 () => Forward;
+        }
     }
     class MarketFace extends BotIncomingSegment.$metadata$.constructor {
         constructor(url: string, summary: string);
@@ -896,9 +962,11 @@ export declare namespace BotIncomingSegment {
         get summary(): string;
         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 MarketFace.$metadata$ {
-        const constructor: abstract new () => MarketFace;
+    namespace MarketFace {
+        /** @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 () => MarketFace;
+        }
     }
     class LightApp extends BotIncomingSegment.$metadata$.constructor {
         constructor(appName: string, jsonPayload: string);
@@ -906,9 +974,11 @@ export declare namespace BotIncomingSegment {
         get jsonPayload(): string;
         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 LightApp.$metadata$ {
-        const constructor: abstract new () => LightApp;
+    namespace LightApp {
+        /** @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 () => LightApp;
+        }
     }
 }
 export declare class BotOutgoingMessageResult {
@@ -916,9 +986,11 @@ export declare class BotOutgoingMessageResult {
     get sequence(): bigint;
     get sendTime(): bigint;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace BotOutgoingMessageResult.$metadata$ {
-    const constructor: abstract new () => BotOutgoingMessageResult;
+export declare namespace BotOutgoingMessageResult {
+    /** @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 () => BotOutgoingMessageResult;
+    }
 }
 export declare abstract class ImageFormat {
     private constructor();
@@ -953,24 +1025,22 @@ export declare abstract class ImageFormat {
     static values(): Array<ImageFormat>;
     static valueOf(value: string): ImageFormat;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace ImageFormat.$metadata$ {
-    const constructor: abstract new () => ImageFormat;
-}
 export declare namespace ImageFormat {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @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 () => ImageFormat;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class constructor {
-            fromExtension(ext: string): Nullable<ImageFormat>;
-            fromUnderlying(value: number): Nullable<ImageFormat>;
-            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 {
+                fromExtension(ext: string): Nullable<ImageFormat>;
+                fromUnderlying(value: number): Nullable<ImageFormat>;
+                private constructor();
+            }
         }
     }
 }
@@ -990,9 +1060,11 @@ export declare abstract class ImageSubType {
     static values(): Array<ImageSubType>;
     static valueOf(value: string): ImageSubType;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace ImageSubType.$metadata$ {
-    const constructor: abstract new () => ImageSubType;
+export declare namespace ImageSubType {
+    /** @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 () => ImageSubType;
+    }
 }
 export declare abstract class MessageScene {
     private constructor();
@@ -1013,9 +1085,11 @@ export declare abstract class MessageScene {
     static values(): Array<MessageScene>;
     static valueOf(value: string): MessageScene;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace MessageScene.$metadata$ {
-    const constructor: abstract new () => MessageScene;
+export declare namespace MessageScene {
+    /** @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 () => MessageScene;
+    }
 }
 export declare class BotFaceDetail {
     constructor(qSid: string, qDes: string, emCode: string, qCid: number, aniStickerType: number, aniStickerPackId: number, aniStickerId: number, url: string, emojiNameAlias: KtList<string>, aniStickerWidth: number, aniStickerHeight: number);
@@ -1035,9 +1109,11 @@ export declare class BotFaceDetail {
     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 */
-export declare namespace BotFaceDetail.$metadata$ {
-    const constructor: abstract new () => BotFaceDetail;
+export declare namespace BotFaceDetail {
+    /** @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 () => BotFaceDetail;
+    }
 }
 export declare class BotFriendData {
     constructor(uin: bigint, uid: string, nickname: string, remark: string, bio: string, qid: string, age: number, gender: UserInfoGender, categoryId: number, categoryName: string);
@@ -1056,9 +1132,11 @@ export declare class BotFriendData {
     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 */
-export declare namespace BotFriendData.$metadata$ {
-    const constructor: abstract new () => BotFriendData;
+export declare namespace BotFriendData {
+    /** @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 () => BotFriendData;
+    }
 }
 export declare class BotFriendRequest {
     constructor(time: bigint, initiatorUin: bigint, initiatorUid: string, targetUserUin: bigint, targetUserUid: string, state: RequestState, comment: string, via: string, isFiltered: boolean);
@@ -1076,22 +1154,20 @@ export declare class BotFriendRequest {
     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 */
-export declare namespace BotFriendRequest.$metadata$ {
-    const constructor: abstract new () => BotFriendRequest;
-}
 export declare namespace BotFriendRequest {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @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 () => BotFriendRequest;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class 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 {
+                private constructor();
+            }
         }
     }
 }
@@ -1108,9 +1184,11 @@ export declare class BotGroupAnnouncement {
     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 */
-export declare namespace BotGroupAnnouncement.$metadata$ {
-    const constructor: abstract new () => BotGroupAnnouncement;
+export declare namespace BotGroupAnnouncement {
+    /** @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 () => BotGroupAnnouncement;
+    }
 }
 export declare class BotGroupData {
     constructor(uin: bigint, name: string, memberCount: number, capacity: number);
@@ -1123,9 +1201,11 @@ export declare class BotGroupData {
     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 */
-export declare namespace BotGroupData.$metadata$ {
-    const constructor: abstract new () => BotGroupData;
+export declare namespace BotGroupData {
+    /** @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 () => BotGroupData;
+    }
 }
 export declare class BotGroupFileEntry {
     constructor(fileId: string, fileName: string, parentFolderId: string, fileSize: bigint, expireTime: bigint, modifiedTime: bigint, uploaderUin: bigint, uploadedTime: bigint, downloadedTimes: number);
@@ -1143,9 +1223,11 @@ export declare class BotGroupFileEntry {
     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 */
-export declare namespace BotGroupFileEntry.$metadata$ {
-    const constructor: abstract new () => BotGroupFileEntry;
+export declare namespace BotGroupFileEntry {
+    /** @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 () => BotGroupFileEntry;
+    }
 }
 export declare class BotGroupFileSystemList {
     constructor(files: KtList<BotGroupFileEntry>, folders: KtList<BotGroupFolderEntry>);
@@ -1156,9 +1238,11 @@ export declare class BotGroupFileSystemList {
     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 */
-export declare namespace BotGroupFileSystemList.$metadata$ {
-    const constructor: abstract new () => BotGroupFileSystemList;
+export declare namespace BotGroupFileSystemList {
+    /** @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 () => BotGroupFileSystemList;
+    }
 }
 export declare class BotGroupFolderEntry {
     constructor(folderId: string, parentFolderId: string, folderName: string, createTime: bigint, modifiedTime: bigint, creatorUin: bigint, totalFileCount: number);
@@ -1174,9 +1258,11 @@ export declare class BotGroupFolderEntry {
     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 */
-export declare namespace BotGroupFolderEntry.$metadata$ {
-    const constructor: abstract new () => BotGroupFolderEntry;
+export declare namespace BotGroupFolderEntry {
+    /** @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 () => BotGroupFolderEntry;
+    }
 }
 export declare class BotGroupMemberData {
     constructor(uin: bigint, uid: string, nickname: string, card: string, specialTitle: string, level: number, joinedAt: bigint, lastSpokeAt: bigint, mutedUntil: Nullable<bigint> | undefined, role: GroupMemberRole);
@@ -1195,18 +1281,20 @@ export declare class BotGroupMemberData {
     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 */
-export declare namespace BotGroupMemberData.$metadata$ {
-    const constructor: abstract new () => BotGroupMemberData;
+export declare namespace BotGroupMemberData {
+    /** @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 () => BotGroupMemberData;
+    }
 }
 export declare abstract class BotGroupNotification {
     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 */
-export declare namespace BotGroupNotification.$metadata$ {
-    const constructor: abstract new () => BotGroupNotification;
-}
 export declare namespace BotGroupNotification {
+    /** @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 () => BotGroupNotification;
+    }
     class JoinRequest extends BotGroupNotification.$metadata$.constructor {
         constructor(groupUin: bigint, notificationSeq: bigint, isFiltered: boolean, initiatorUin: bigint, initiatorUid: string, state: RequestState, operatorUin: Nullable<bigint>, operatorUid: Nullable<string>, comment: string);
         get groupUin(): bigint;
@@ -1223,9 +1311,11 @@ export declare namespace BotGroupNotification {
         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 JoinRequest.$metadata$ {
-        const constructor: abstract new () => JoinRequest;
+    namespace JoinRequest {
+        /** @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 () => JoinRequest;
+        }
     }
     class AdminChange extends BotGroupNotification.$metadata$.constructor {
         constructor(groupUin: bigint, notificationSeq: bigint, targetUserUin: bigint, targetUserUid: string, isSet: boolean, operatorUin: bigint, operatorUid: string);
@@ -1241,9 +1331,11 @@ export declare namespace BotGroupNotification {
         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 AdminChange.$metadata$ {
-        const constructor: abstract new () => AdminChange;
+    namespace AdminChange {
+        /** @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 () => AdminChange;
+        }
     }
     class Kick extends BotGroupNotification.$metadata$.constructor {
         constructor(groupUin: bigint, notificationSeq: bigint, targetUserUin: bigint, targetUserUid: string, operatorUin: bigint, operatorUid: string);
@@ -1258,9 +1350,11 @@ export declare namespace BotGroupNotification {
         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 Kick.$metadata$ {
-        const constructor: abstract new () => Kick;
+    namespace Kick {
+        /** @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 () => Kick;
+        }
     }
     class Quit extends BotGroupNotification.$metadata$.constructor {
         constructor(groupUin: bigint, notificationSeq: bigint, targetUserUin: bigint, targetUserUid: string);
@@ -1273,9 +1367,11 @@ export declare namespace BotGroupNotification {
         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 Quit.$metadata$ {
-        const constructor: abstract new () => Quit;
+    namespace Quit {
+        /** @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 () => Quit;
+        }
     }
     class InvitedJoinRequest extends BotGroupNotification.$metadata$.constructor {
         constructor(groupUin: bigint, notificationSeq: bigint, initiatorUin: bigint, initiatorUid: string, targetUserUin: bigint, targetUserUid: string, state: RequestState, operatorUin: Nullable<bigint>, operatorUid: Nullable<string>);
@@ -1293,21 +1389,21 @@ export declare namespace BotGroupNotification {
         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 InvitedJoinRequest.$metadata$ {
-        const constructor: abstract new () => InvitedJoinRequest;
+    namespace InvitedJoinRequest {
+        /** @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 () => InvitedJoinRequest;
+        }
     }
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class 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 {
+                private constructor();
+            }
         }
     }
 }
@@ -1330,9 +1426,11 @@ export declare class BotUserInfo {
     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 */
-export declare namespace BotUserInfo.$metadata$ {
-    const constructor: abstract new () => BotUserInfo;
+export declare namespace BotUserInfo {
+    /** @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 () => BotUserInfo;
+    }
 }
 export declare abstract class GroupMemberRole {
     private constructor();
@@ -1354,23 +1452,21 @@ export declare abstract class GroupMemberRole {
     static values(): Array<GroupMemberRole>;
     static valueOf(value: string): GroupMemberRole;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace GroupMemberRole.$metadata$ {
-    const constructor: abstract new () => GroupMemberRole;
-}
 export declare namespace GroupMemberRole {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @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 () => GroupMemberRole;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class constructor {
-            from(value: number): GroupMemberRole;
-            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 {
+                from(value: number): GroupMemberRole;
+                private constructor();
+            }
         }
     }
 }
@@ -1406,22 +1502,20 @@ export declare abstract class QRCodeState {
     static values(): Array<QRCodeState>;
     static valueOf(value: string): QRCodeState;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace QRCodeState.$metadata$ {
-    const constructor: abstract new () => QRCodeState;
-}
 export declare namespace QRCodeState {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @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 () => QRCodeState;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class 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 {
+                private constructor();
+            }
         }
     }
 }
@@ -1449,23 +1543,21 @@ export declare abstract class RequestState {
     static values(): Array<RequestState>;
     static valueOf(value: string): RequestState;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace RequestState.$metadata$ {
-    const constructor: abstract new () => RequestState;
-}
 export declare namespace RequestState {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @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 () => RequestState;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class constructor {
-            from(value: number): RequestState;
-            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 {
+                from(value: number): RequestState;
+                private constructor();
+            }
         }
     }
 }
@@ -1493,23 +1585,21 @@ export declare abstract class UserInfoGender {
     static values(): Array<UserInfoGender>;
     static valueOf(value: string): UserInfoGender;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace UserInfoGender.$metadata$ {
-    const constructor: abstract new () => UserInfoGender;
-}
 export declare namespace UserInfoGender {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @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 () => UserInfoGender;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class constructor {
-            from(value: number): UserInfoGender;
-            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 {
+                from(value: number): UserInfoGender;
+                private constructor();
+            }
         }
     }
 }
@@ -1631,22 +1721,20 @@ export declare class Bot /* implements CoroutineScope */ {
     offSessionStoreUpdated(callback: (p0: SessionStoreUpdatedEvent) => any): boolean;
     static create(appInfo: AppInfo, sessionStore: SessionStore, signProvider: SignProvider, jsScope: CoroutineScope, minLogLevel: LogLevel, logHandler: LogHandler): Promise<Bot>;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace Bot.$metadata$ {
-    const constructor: abstract new () => Bot;
-}
 export declare namespace Bot {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @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 () => Bot;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class 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 {
+                private constructor();
+            }
         }
     }
 }
@@ -1655,9 +1743,11 @@ export declare class BotForwardBlockBuilder {
     get underlying(): any/* BotForwardBlockBuilder */;
     node(senderUin: bigint, senderName: string, block: (p0: BotOutgoingMessageBuilder) => Promise<void>): void;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace BotForwardBlockBuilder.$metadata$ {
-    const constructor: abstract new () => BotForwardBlockBuilder;
+export declare namespace BotForwardBlockBuilder {
+    /** @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 () => BotForwardBlockBuilder;
+    }
 }
 export declare class BotOutgoingMessageBuilder {
     private constructor();
@@ -1670,18 +1760,22 @@ export declare class BotOutgoingMessageBuilder {
     video(raw: Int8Array, width: number, height: number, duration: bigint, thumb: Int8Array, thumbFormat: ImageFormat): void;
     forward(block: (p0: BotForwardBlockBuilder) => Promise<void>): void;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace BotOutgoingMessageBuilder.$metadata$ {
-    const constructor: abstract new () => BotOutgoingMessageBuilder;
+export declare namespace BotOutgoingMessageBuilder {
+    /** @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 () => BotOutgoingMessageBuilder;
+    }
 }
 export declare class CoroutineScope {
     constructor(isSupervised?: boolean);
     get isSupervised(): boolean;
     cancel(): void;
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace CoroutineScope.$metadata$ {
-    const constructor: abstract new () => CoroutineScope;
+export declare namespace CoroutineScope {
+    /** @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 () => CoroutineScope;
+    }
 }
 export declare class JsGroupNotifications {
     constructor(notifications: Array<BotGroupNotification>, nextSequence: Nullable<bigint>);
@@ -1692,9 +1786,11 @@ export declare class JsGroupNotifications {
     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 */
-export declare namespace JsGroupNotifications.$metadata$ {
-    const constructor: abstract new () => JsGroupNotifications;
+export declare namespace JsGroupNotifications {
+    /** @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 () => JsGroupNotifications;
+    }
 }
 export declare interface SignProvider {
     sign(cmd: string, seq: number, src: Int8Array): Promise<SignResult>;
@@ -1708,7 +1804,9 @@ export declare class UrlSignProvider implements SignProvider {
     sign(cmd: string, seq: number, src: Int8Array): Promise<SignResult>;
     readonly __doNotUseOrImplementIt: SignProvider["__doNotUseOrImplementIt"];
 }
-/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-export declare namespace UrlSignProvider.$metadata$ {
-    const constructor: abstract new () => UrlSignProvider;
+export declare namespace UrlSignProvider {
+    /** @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 () => UrlSignProvider;
+    }
 }