@acidify/core 0.3.0-beta.1

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

@@ -0,0 +1,1714 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare interface KtList<E> /* extends Collection<E> */ {
+    asJsReadonlyArrayView(): ReadonlyArray<E>;
+    readonly __doNotUseOrImplementIt: {
+        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 interface KtMap<K, V> {
+    asJsReadonlyMapView(): ReadonlyMap<K, V>;
+    readonly __doNotUseOrImplementIt: {
+        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();
+    }
+}
+/** @deprecated  */
+export declare const initHook: { get(): any; };
+export declare class AppInfo {
+    constructor(os: string, kernel: string, vendorOs: string, currentVersion: string, miscBitmap: number, ptVersion: string, ssoVersion: number, packageName: string, wtLoginSdk: string, appId: number, subAppId: number, appClientVersion: number, mainSigMap: number, subSigMap: number, ntLoginType: number);
+    get os(): string;
+    get kernel(): string;
+    get vendorOs(): string;
+    get currentVersion(): string;
+    get miscBitmap(): number;
+    get ptVersion(): string;
+    get ssoVersion(): number;
+    get packageName(): string;
+    get wtLoginSdk(): string;
+    get appId(): number;
+    get subAppId(): number;
+    get appClientVersion(): number;
+    get mainSigMap(): number;
+    get subSigMap(): number;
+    get ntLoginType(): number;
+    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;
+        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();
+        }
+    }
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$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 */
+    namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            private constructor();
+        }
+    }
+}
+export declare class SessionStore {
+    constructor(uin: bigint, uid: string, a2: Int8Array, d2: Int8Array, d2Key: Int8Array, tgtgt: Int8Array, encryptedA1: Int8Array, noPicSig: Int8Array, qrSig: Int8Array, guid: Int8Array, deviceName: string);
+    get uin(): bigint;
+    set uin(value: bigint);
+    get uid(): string;
+    set uid(value: string);
+    get a2(): Int8Array;
+    set a2(value: Int8Array);
+    get d2(): Int8Array;
+    set d2(value: Int8Array);
+    get d2Key(): Int8Array;
+    set d2Key(value: Int8Array);
+    get tgtgt(): Int8Array;
+    set tgtgt(value: Int8Array);
+    get encryptedA1(): Int8Array;
+    set encryptedA1(value: Int8Array);
+    get noPicSig(): Int8Array;
+    set noPicSig(value: Int8Array);
+    get qrSig(): Int8Array;
+    set qrSig(value: Int8Array);
+    get guid(): Int8Array;
+    set guid(value: Int8Array);
+    get deviceName(): string;
+    clear(): void;
+    refreshDeviceGuid(): void;
+    toJson(): string;
+    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;
+        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();
+        }
+    }
+}
+export declare class SignResult {
+    constructor(sign: Int8Array, token: Int8Array, extra: Int8Array);
+    get sign(): Int8Array;
+    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 class BotFriend /* extends AbstractEntity<BotFriendData> */ {
+    private constructor();
+    get uin(): bigint;
+    get uid(): string;
+    get nickname(): string;
+    get remark(): string;
+    get bio(): string;
+    get qid(): string;
+    get age(): number;
+    get gender(): UserInfoGender;
+    get categoryId(): number;
+    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 class BotGroup /* extends AbstractEntity<BotGroupData> */ {
+    private constructor();
+    get uin(): bigint;
+    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 class BotGroupMember /* extends AbstractEntity<BotGroupMemberData> */ {
+    private constructor();
+    get group(): BotGroup;
+    get uin(): bigint;
+    get uid(): string;
+    get nickname(): string;
+    get card(): string;
+    get specialTitle(): string;
+    get level(): number;
+    get joinedAt(): bigint;
+    get lastSpokeAt(): bigint;
+    get mutedUntil(): Nullable<bigint>;
+    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 interface AcidifyEvent {
+    readonly __doNotUseOrImplementIt: {
+        readonly "org.ntqqrev.acidify.event.AcidifyEvent": unique symbol;
+    };
+}
+export declare class BotOfflineEvent implements AcidifyEvent {
+    constructor(reason: string);
+    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 class FriendFileUploadEvent implements AcidifyEvent {
+    constructor(userUin: bigint, userUid: string, fileId: string, fileName: string, fileSize: bigint, fileHash: string, isSelf: boolean);
+    get userUin(): bigint;
+    get userUid(): string;
+    get fileId(): string;
+    get fileName(): string;
+    get fileSize(): bigint;
+    get fileHash(): string;
+    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 class FriendNudgeEvent implements AcidifyEvent {
+    constructor(userUin: bigint, userUid: string, isSelfSend: boolean, isSelfReceive: boolean, displayAction: string, displaySuffix: string, displayActionImgUrl: string);
+    get userUin(): bigint;
+    get userUid(): string;
+    get isSelfSend(): boolean;
+    get isSelfReceive(): boolean;
+    get displayAction(): string;
+    get displaySuffix(): string;
+    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 class FriendRequestEvent implements AcidifyEvent {
+    constructor(initiatorUin: bigint, initiatorUid: string, comment: string, via: string);
+    get initiatorUin(): bigint;
+    get initiatorUid(): string;
+    get comment(): string;
+    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 class GroupAdminChangeEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, userUin: bigint, userUid: string, isSet: boolean);
+    get groupUin(): bigint;
+    get userUin(): bigint;
+    get userUid(): string;
+    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 class GroupEssenceMessageChangeEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, messageSeq: bigint, isSet: boolean);
+    get groupUin(): bigint;
+    get messageSeq(): bigint;
+    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 class GroupFileUploadEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, userUin: bigint, userUid: string, fileId: string, fileName: string, fileSize: bigint);
+    get groupUin(): bigint;
+    get userUin(): bigint;
+    get userUid(): string;
+    get fileId(): string;
+    get fileName(): string;
+    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 class GroupInvitationEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, invitationSeq: bigint, initiatorUin: bigint, initiatorUid: string);
+    get groupUin(): bigint;
+    get invitationSeq(): bigint;
+    get initiatorUin(): bigint;
+    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 class GroupInvitedJoinRequestEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, notificationSeq: bigint, initiatorUin: bigint, initiatorUid: string, targetUserUin: bigint, targetUserUid: string);
+    get groupUin(): bigint;
+    get notificationSeq(): bigint;
+    get initiatorUin(): bigint;
+    get initiatorUid(): string;
+    get targetUserUin(): bigint;
+    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 class GroupJoinRequestEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, notificationSeq: bigint, isFiltered: boolean, initiatorUin: bigint, initiatorUid: string, comment: string);
+    get groupUin(): bigint;
+    get notificationSeq(): bigint;
+    get isFiltered(): boolean;
+    get initiatorUin(): bigint;
+    get initiatorUid(): string;
+    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 class GroupMemberDecreaseEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, userUin: bigint, userUid: string, operatorUin: Nullable<bigint>, operatorUid: Nullable<string>);
+    get groupUin(): bigint;
+    get userUin(): bigint;
+    get userUid(): string;
+    get operatorUin(): Nullable<bigint>;
+    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 class GroupMemberIncreaseEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, userUin: bigint, userUid: string, operatorUin: Nullable<bigint>, operatorUid: Nullable<string>, invitorUin: Nullable<bigint>, invitorUid: Nullable<string>);
+    get groupUin(): bigint;
+    get userUin(): bigint;
+    get userUid(): string;
+    get operatorUin(): Nullable<bigint>;
+    get operatorUid(): Nullable<string>;
+    get invitorUin(): Nullable<bigint>;
+    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 class GroupMessageReactionEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, userUin: bigint, userUid: string, messageSeq: bigint, faceId: string, isAdd: boolean);
+    get groupUin(): bigint;
+    get userUin(): bigint;
+    get userUid(): string;
+    get messageSeq(): bigint;
+    get faceId(): string;
+    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 class GroupMuteEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, userUin: bigint, userUid: string, operatorUin: bigint, operatorUid: string, duration: number);
+    get groupUin(): bigint;
+    get userUin(): bigint;
+    get userUid(): string;
+    get operatorUin(): bigint;
+    get operatorUid(): string;
+    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 class GroupNameChangeEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, newGroupName: string, operatorUin: bigint, operatorUid: string);
+    get groupUin(): bigint;
+    get newGroupName(): string;
+    get operatorUin(): bigint;
+    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 class GroupNudgeEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, senderUin: bigint, senderUid: string, receiverUin: bigint, receiverUid: string, displayAction: string, displaySuffix: string, displayActionImgUrl: string);
+    get groupUin(): bigint;
+    get senderUin(): bigint;
+    get senderUid(): string;
+    get receiverUin(): bigint;
+    get receiverUid(): string;
+    get displayAction(): string;
+    get displaySuffix(): string;
+    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 class GroupWholeMuteEvent implements AcidifyEvent {
+    constructor(groupUin: bigint, operatorUin: bigint, operatorUid: string, isMute: boolean);
+    get groupUin(): bigint;
+    get operatorUin(): bigint;
+    get operatorUid(): string;
+    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 class MessageRecallEvent implements AcidifyEvent {
+    constructor(scene: MessageScene, peerUin: bigint, messageSeq: bigint, senderUin: bigint, senderUid: string, operatorUin: bigint, operatorUid: string, displaySuffix: string);
+    get scene(): MessageScene;
+    get peerUin(): bigint;
+    get messageSeq(): bigint;
+    get senderUin(): bigint;
+    get senderUid(): string;
+    get operatorUin(): bigint;
+    get operatorUid(): string;
+    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 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 class QRCodeGeneratedEvent implements AcidifyEvent {
+    constructor(url: string, png: Int8Array);
+    get url(): string;
+    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 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 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 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 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 class OidbException extends /* Exception */ Error {
+    constructor(oidbCommand: number, oidbService: number, oidbResult: number, oidbErrorMsg: string);
+    get oidbCommand(): number;
+    get oidbService(): number;
+    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 class ServiceException extends /* Exception */ Error {
+    constructor(cmd: string, retCode: number, extra: string);
+    get cmd(): string;
+    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 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 class WtLoginException extends /* Exception */ Error {
+    constructor(code: number, tag: string, msg: string);
+    get code(): number;
+    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 interface LogHandler {
+    handleLog(level: LogLevel, tag: string, message: string, throwable: Nullable<Error>): void;
+    readonly __doNotUseOrImplementIt: {
+        readonly "org.ntqqrev.acidify.logging.LogHandler": unique symbol;
+    };
+}
+export declare abstract class LogLevel {
+    private constructor();
+    static get VERBOSE(): LogLevel & {
+        get name(): "VERBOSE";
+        get ordinal(): 0;
+    };
+    static get DEBUG(): LogLevel & {
+        get name(): "DEBUG";
+        get ordinal(): 1;
+    };
+    static get INFO(): LogLevel & {
+        get name(): "INFO";
+        get ordinal(): 2;
+    };
+    static get WARN(): LogLevel & {
+        get name(): "WARN";
+        get ordinal(): 3;
+    };
+    static get ERROR(): LogLevel & {
+        get name(): "ERROR";
+        get ordinal(): 4;
+    };
+    get name(): "VERBOSE" | "DEBUG" | "INFO" | "WARN" | "ERROR";
+    get ordinal(): 0 | 1 | 2 | 3 | 4;
+    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 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 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 class BotEssenceMessage {
+    constructor(groupUin: bigint, messageSeq: bigint, messageTime: bigint, senderUin: bigint, senderName: string, operatorUin: bigint, operatorName: string, operationTime: bigint, segments: KtList<BotEssenceSegment>);
+    get groupUin(): bigint;
+    get messageSeq(): bigint;
+    get messageTime(): bigint;
+    get senderUin(): bigint;
+    get senderName(): string;
+    get operatorUin(): bigint;
+    get operatorName(): string;
+    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;
+        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();
+        }
+    }
+}
+export declare class BotEssenceMessageResult {
+    constructor(messages: KtList<BotEssenceMessage>, isEnd: boolean);
+    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 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 {
+    class Text extends BotEssenceSegment.$metadata$.constructor {
+        constructor(text: string);
+        get text(): string;
+        toString(): string;
+        copy(text?: string): BotEssenceSegment.Text;
+        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;
+    }
+    class Face extends BotEssenceSegment.$metadata$.constructor {
+        constructor(faceId: number);
+        get faceId(): number;
+        toString(): string;
+        copy(faceId?: number): BotEssenceSegment.Face;
+        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;
+    }
+    class Image extends BotEssenceSegment.$metadata$.constructor {
+        constructor(imageUrl: string);
+        get imageUrl(): string;
+        toString(): string;
+        copy(imageUrl?: string): BotEssenceSegment.Image;
+        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;
+    }
+    class Video extends BotEssenceSegment.$metadata$.constructor {
+        constructor(thumbnailUrl: string);
+        get thumbnailUrl(): string;
+        toString(): string;
+        copy(thumbnailUrl?: string): BotEssenceSegment.Video;
+        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;
+    }
+}
+export declare class BotForwardedMessage {
+    constructor(senderName: string, avatarUrl: string, timestamp: bigint);
+    get senderName(): string;
+    get avatarUrl(): string;
+    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;
+        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();
+        }
+    }
+}
+export declare class BotHistoryMessages {
+    constructor(messages: KtList<BotIncomingMessage>, nextStartSequence?: Nullable<bigint>);
+    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 class BotIncomingMessage {
+    constructor(scene: MessageScene, peerUin: bigint, peerUid: string, sequence: bigint, timestamp: bigint, senderUin: bigint, senderUid: string, clientSequence: bigint, random: number, messageUid: bigint);
+    get scene(): MessageScene;
+    get peerUin(): bigint;
+    get peerUid(): string;
+    get sequence(): bigint;
+    get timestamp(): bigint;
+    get senderUin(): bigint;
+    get senderUid(): string;
+    get clientSequence(): bigint;
+    get random(): number;
+    get messageUid(): bigint;
+    get segments(): KtList<BotIncomingSegment>;
+    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 {
+    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;
+    }
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$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 */
+    namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        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 {
+    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;
+    }
+    class Mention extends BotIncomingSegment.$metadata$.constructor {
+        constructor(uin: Nullable<bigint> | undefined, name: string);
+        get uin(): Nullable<bigint>;
+        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;
+    }
+    class Face extends BotIncomingSegment.$metadata$.constructor {
+        constructor(faceId: number, summary: string, isLarge: boolean);
+        get faceId(): number;
+        get summary(): string;
+        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;
+    }
+    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;
+    }
+    class Image extends BotIncomingSegment.$metadata$.constructor {
+        constructor(fileId: string, width: number, height: number, subType: ImageSubType, summary: string);
+        get fileId(): string;
+        get width(): number;
+        get height(): number;
+        get subType(): ImageSubType;
+        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;
+    }
+    class Record extends BotIncomingSegment.$metadata$.constructor {
+        constructor(fileId: string, duration: number);
+        get fileId(): string;
+        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;
+    }
+    class Video extends BotIncomingSegment.$metadata$.constructor {
+        constructor(fileId: string, duration: number, width: number, height: number);
+        get fileId(): string;
+        get duration(): number;
+        get width(): number;
+        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;
+    }
+    class File extends BotIncomingSegment.$metadata$.constructor {
+        constructor(fileId: string, fileName: string, fileSize: bigint, fileHash?: Nullable<string>);
+        get fileId(): string;
+        get fileName(): string;
+        get fileSize(): bigint;
+        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;
+    }
+    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;
+    }
+    class MarketFace extends BotIncomingSegment.$metadata$.constructor {
+        constructor(url: string, summary: string);
+        get url(): string;
+        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;
+    }
+    class LightApp extends BotIncomingSegment.$metadata$.constructor {
+        constructor(appName: string, jsonPayload: string);
+        get appName(): string;
+        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;
+    }
+}
+export declare class BotOutgoingMessageResult {
+    constructor(sequence: bigint, sendTime: bigint);
+    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 abstract class ImageFormat {
+    private constructor();
+    static get PNG(): ImageFormat & {
+        get name(): "PNG";
+        get ordinal(): 0;
+    };
+    static get GIF(): ImageFormat & {
+        get name(): "GIF";
+        get ordinal(): 1;
+    };
+    static get JPEG(): ImageFormat & {
+        get name(): "JPEG";
+        get ordinal(): 2;
+    };
+    static get BMP(): ImageFormat & {
+        get name(): "BMP";
+        get ordinal(): 3;
+    };
+    static get WEBP(): ImageFormat & {
+        get name(): "WEBP";
+        get ordinal(): 4;
+    };
+    static get TIFF(): ImageFormat & {
+        get name(): "TIFF";
+        get ordinal(): 5;
+    };
+    get name(): "PNG" | "GIF" | "JPEG" | "BMP" | "WEBP" | "TIFF";
+    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+    get ext(): string;
+    get underlying(): number;
+    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;
+        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();
+        }
+    }
+}
+export declare abstract class ImageSubType {
+    private constructor();
+    static get NORMAL(): ImageSubType & {
+        get name(): "NORMAL";
+        get ordinal(): 0;
+    };
+    static get STICKER(): ImageSubType & {
+        get name(): "STICKER";
+        get ordinal(): 1;
+    };
+    get name(): "NORMAL" | "STICKER";
+    get ordinal(): 0 | 1;
+    get underlying(): number;
+    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 abstract class MessageScene {
+    private constructor();
+    static get FRIEND(): MessageScene & {
+        get name(): "FRIEND";
+        get ordinal(): 0;
+    };
+    static get GROUP(): MessageScene & {
+        get name(): "GROUP";
+        get ordinal(): 1;
+    };
+    static get TEMP(): MessageScene & {
+        get name(): "TEMP";
+        get ordinal(): 2;
+    };
+    get name(): "FRIEND" | "GROUP" | "TEMP";
+    get ordinal(): 0 | 1 | 2;
+    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 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);
+    get qSid(): string;
+    get qDes(): string;
+    get emCode(): string;
+    get qCid(): number;
+    get aniStickerType(): number;
+    get aniStickerPackId(): number;
+    get aniStickerId(): number;
+    get url(): string;
+    get emojiNameAlias(): KtList<string>;
+    get aniStickerWidth(): number;
+    get aniStickerHeight(): number;
+    copy(qSid?: string, qDes?: string, emCode?: string, qCid?: number, aniStickerType?: number, aniStickerPackId?: number, aniStickerId?: number, url?: string, emojiNameAlias?: KtList<string>, aniStickerWidth?: number, aniStickerHeight?: number): BotFaceDetail;
+    toString(): string;
+    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 class BotFriendData {
+    constructor(uin: bigint, uid: string, nickname: string, remark: string, bio: string, qid: string, age: number, gender: UserInfoGender, categoryId: number, categoryName: string);
+    get uin(): bigint;
+    get uid(): string;
+    get nickname(): string;
+    get remark(): string;
+    get bio(): string;
+    get qid(): string;
+    get age(): number;
+    get gender(): UserInfoGender;
+    get categoryId(): number;
+    get categoryName(): string;
+    copy(uin?: bigint, uid?: string, nickname?: string, remark?: string, bio?: string, qid?: string, age?: number, gender?: UserInfoGender, categoryId?: number, categoryName?: string): BotFriendData;
+    toString(): string;
+    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 class BotFriendRequest {
+    constructor(time: bigint, initiatorUin: bigint, initiatorUid: string, targetUserUin: bigint, targetUserUid: string, state: RequestState, comment: string, via: string, isFiltered: boolean);
+    get time(): bigint;
+    get initiatorUin(): bigint;
+    get initiatorUid(): string;
+    get targetUserUin(): bigint;
+    get targetUserUid(): string;
+    get state(): RequestState;
+    get comment(): string;
+    get via(): string;
+    get isFiltered(): boolean;
+    copy(time?: bigint, initiatorUin?: bigint, initiatorUid?: string, targetUserUin?: bigint, targetUserUid?: string, state?: RequestState, comment?: string, via?: string, isFiltered?: boolean): BotFriendRequest;
+    toString(): string;
+    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;
+        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();
+        }
+    }
+}
+export declare class BotGroupAnnouncement {
+    constructor(groupUin: bigint, announcementId: string, senderId: bigint, time: bigint, content: string, imageUrl?: Nullable<string>);
+    get groupUin(): bigint;
+    get announcementId(): string;
+    get senderId(): bigint;
+    get time(): bigint;
+    get content(): string;
+    get imageUrl(): Nullable<string>;
+    copy(groupUin?: bigint, announcementId?: string, senderId?: bigint, time?: bigint, content?: string, imageUrl?: Nullable<string>): BotGroupAnnouncement;
+    toString(): string;
+    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 class BotGroupData {
+    constructor(uin: bigint, name: string, memberCount: number, capacity: number);
+    get uin(): bigint;
+    get name(): string;
+    get memberCount(): number;
+    get capacity(): number;
+    copy(uin?: bigint, name?: string, memberCount?: number, capacity?: number): BotGroupData;
+    toString(): string;
+    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 class BotGroupFileEntry {
+    constructor(fileId: string, fileName: string, parentFolderId: string, fileSize: bigint, expireTime: bigint, modifiedTime: bigint, uploaderUin: bigint, uploadedTime: bigint, downloadedTimes: number);
+    get fileId(): string;
+    get fileName(): string;
+    get parentFolderId(): string;
+    get fileSize(): bigint;
+    get expireTime(): bigint;
+    get modifiedTime(): bigint;
+    get uploaderUin(): bigint;
+    get uploadedTime(): bigint;
+    get downloadedTimes(): number;
+    copy(fileId?: string, fileName?: string, parentFolderId?: string, fileSize?: bigint, expireTime?: bigint, modifiedTime?: bigint, uploaderUin?: bigint, uploadedTime?: bigint, downloadedTimes?: number): BotGroupFileEntry;
+    toString(): string;
+    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 class BotGroupFileSystemList {
+    constructor(files: KtList<BotGroupFileEntry>, folders: KtList<BotGroupFolderEntry>);
+    get files(): KtList<BotGroupFileEntry>;
+    get folders(): KtList<BotGroupFolderEntry>;
+    copy(files?: KtList<BotGroupFileEntry>, folders?: KtList<BotGroupFolderEntry>): BotGroupFileSystemList;
+    toString(): string;
+    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 class BotGroupFolderEntry {
+    constructor(folderId: string, parentFolderId: string, folderName: string, createTime: bigint, modifiedTime: bigint, creatorUin: bigint, totalFileCount: number);
+    get folderId(): string;
+    get parentFolderId(): string;
+    get folderName(): string;
+    get createTime(): bigint;
+    get modifiedTime(): bigint;
+    get creatorUin(): bigint;
+    get totalFileCount(): number;
+    copy(folderId?: string, parentFolderId?: string, folderName?: string, createTime?: bigint, modifiedTime?: bigint, creatorUin?: bigint, totalFileCount?: number): BotGroupFolderEntry;
+    toString(): string;
+    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 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);
+    get uin(): bigint;
+    get uid(): string;
+    get nickname(): string;
+    get card(): string;
+    get specialTitle(): string;
+    get level(): number;
+    get joinedAt(): bigint;
+    get lastSpokeAt(): bigint;
+    get mutedUntil(): Nullable<bigint>;
+    get role(): GroupMemberRole;
+    copy(uin?: bigint, uid?: string, nickname?: string, card?: string, specialTitle?: string, level?: number, joinedAt?: bigint, lastSpokeAt?: bigint, mutedUntil?: Nullable<bigint>, role?: GroupMemberRole): BotGroupMemberData;
+    toString(): string;
+    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 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 {
+    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;
+        get notificationSeq(): bigint;
+        get isFiltered(): boolean;
+        get initiatorUin(): bigint;
+        get initiatorUid(): string;
+        get state(): RequestState;
+        get operatorUin(): Nullable<bigint>;
+        get operatorUid(): Nullable<string>;
+        get comment(): string;
+        copy(groupUin?: bigint, notificationSeq?: bigint, isFiltered?: boolean, initiatorUin?: bigint, initiatorUid?: string, state?: RequestState, operatorUin?: Nullable<bigint>, operatorUid?: Nullable<string>, comment?: string): BotGroupNotification.JoinRequest;
+        toString(): string;
+        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;
+    }
+    class AdminChange extends BotGroupNotification.$metadata$.constructor {
+        constructor(groupUin: bigint, notificationSeq: bigint, targetUserUin: bigint, targetUserUid: string, isSet: boolean, operatorUin: bigint, operatorUid: string);
+        get groupUin(): bigint;
+        get notificationSeq(): bigint;
+        get targetUserUin(): bigint;
+        get targetUserUid(): string;
+        get isSet(): boolean;
+        get operatorUin(): bigint;
+        get operatorUid(): string;
+        copy(groupUin?: bigint, notificationSeq?: bigint, targetUserUin?: bigint, targetUserUid?: string, isSet?: boolean, operatorUin?: bigint, operatorUid?: string): BotGroupNotification.AdminChange;
+        toString(): string;
+        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;
+    }
+    class Kick extends BotGroupNotification.$metadata$.constructor {
+        constructor(groupUin: bigint, notificationSeq: bigint, targetUserUin: bigint, targetUserUid: string, operatorUin: bigint, operatorUid: string);
+        get groupUin(): bigint;
+        get notificationSeq(): bigint;
+        get targetUserUin(): bigint;
+        get targetUserUid(): string;
+        get operatorUin(): bigint;
+        get operatorUid(): string;
+        copy(groupUin?: bigint, notificationSeq?: bigint, targetUserUin?: bigint, targetUserUid?: string, operatorUin?: bigint, operatorUid?: string): BotGroupNotification.Kick;
+        toString(): string;
+        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;
+    }
+    class Quit extends BotGroupNotification.$metadata$.constructor {
+        constructor(groupUin: bigint, notificationSeq: bigint, targetUserUin: bigint, targetUserUid: string);
+        get groupUin(): bigint;
+        get notificationSeq(): bigint;
+        get targetUserUin(): bigint;
+        get targetUserUid(): string;
+        copy(groupUin?: bigint, notificationSeq?: bigint, targetUserUin?: bigint, targetUserUid?: string): BotGroupNotification.Quit;
+        toString(): string;
+        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;
+    }
+    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>);
+        get groupUin(): bigint;
+        get notificationSeq(): bigint;
+        get initiatorUin(): bigint;
+        get initiatorUid(): string;
+        get targetUserUin(): bigint;
+        get targetUserUid(): string;
+        get state(): RequestState;
+        get operatorUin(): Nullable<bigint>;
+        get operatorUid(): Nullable<string>;
+        copy(groupUin?: bigint, notificationSeq?: bigint, initiatorUin?: bigint, initiatorUid?: string, targetUserUin?: bigint, targetUserUid?: string, state?: RequestState, operatorUin?: Nullable<bigint>, operatorUid?: Nullable<string>): BotGroupNotification.InvitedJoinRequest;
+        toString(): string;
+        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;
+    }
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$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 */
+    namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            private constructor();
+        }
+    }
+}
+export declare class BotUserInfo {
+    constructor(uin: bigint, nickname: string, bio: string, gender: UserInfoGender, remark: string, level: number, country: string, city: string, school: string, registerTime: bigint, age: number, qid: string);
+    get uin(): bigint;
+    get nickname(): string;
+    get bio(): string;
+    get gender(): UserInfoGender;
+    get remark(): string;
+    get level(): number;
+    get country(): string;
+    get city(): string;
+    get school(): string;
+    get registerTime(): bigint;
+    get age(): number;
+    get qid(): string;
+    copy(uin?: bigint, nickname?: string, bio?: string, gender?: UserInfoGender, remark?: string, level?: number, country?: string, city?: string, school?: string, registerTime?: bigint, age?: number, qid?: string): BotUserInfo;
+    toString(): string;
+    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 abstract class GroupMemberRole {
+    private constructor();
+    static get MEMBER(): GroupMemberRole & {
+        get name(): "MEMBER";
+        get ordinal(): 0;
+    };
+    static get ADMIN(): GroupMemberRole & {
+        get name(): "ADMIN";
+        get ordinal(): 1;
+    };
+    static get OWNER(): GroupMemberRole & {
+        get name(): "OWNER";
+        get ordinal(): 2;
+    };
+    get name(): "MEMBER" | "ADMIN" | "OWNER";
+    get ordinal(): 0 | 1 | 2;
+    get value(): number;
+    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;
+        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();
+        }
+    }
+}
+export declare abstract class QRCodeState {
+    private constructor();
+    static get UNKNOWN(): QRCodeState & {
+        get name(): "UNKNOWN";
+        get ordinal(): 0;
+    };
+    static get CONFIRMED(): QRCodeState & {
+        get name(): "CONFIRMED";
+        get ordinal(): 1;
+    };
+    static get CODE_EXPIRED(): QRCodeState & {
+        get name(): "CODE_EXPIRED";
+        get ordinal(): 2;
+    };
+    static get WAITING_FOR_SCAN(): QRCodeState & {
+        get name(): "WAITING_FOR_SCAN";
+        get ordinal(): 3;
+    };
+    static get WAITING_FOR_CONFIRMATION(): QRCodeState & {
+        get name(): "WAITING_FOR_CONFIRMATION";
+        get ordinal(): 4;
+    };
+    static get CANCELLED(): QRCodeState & {
+        get name(): "CANCELLED";
+        get ordinal(): 5;
+    };
+    get name(): "UNKNOWN" | "CONFIRMED" | "CODE_EXPIRED" | "WAITING_FOR_SCAN" | "WAITING_FOR_CONFIRMATION" | "CANCELLED";
+    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+    get value(): number;
+    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;
+        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();
+        }
+    }
+}
+export declare abstract class RequestState {
+    private constructor();
+    static get DEFAULT(): RequestState & {
+        get name(): "DEFAULT";
+        get ordinal(): 0;
+    };
+    static get PENDING(): RequestState & {
+        get name(): "PENDING";
+        get ordinal(): 1;
+    };
+    static get ACCEPTED(): RequestState & {
+        get name(): "ACCEPTED";
+        get ordinal(): 2;
+    };
+    static get REJECTED(): RequestState & {
+        get name(): "REJECTED";
+        get ordinal(): 3;
+    };
+    get name(): "DEFAULT" | "PENDING" | "ACCEPTED" | "REJECTED";
+    get ordinal(): 0 | 1 | 2 | 3;
+    get value(): number;
+    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;
+        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();
+        }
+    }
+}
+export declare abstract class UserInfoGender {
+    private constructor();
+    static get UNSET(): UserInfoGender & {
+        get name(): "UNSET";
+        get ordinal(): 0;
+    };
+    static get MALE(): UserInfoGender & {
+        get name(): "MALE";
+        get ordinal(): 1;
+    };
+    static get FEMALE(): UserInfoGender & {
+        get name(): "FEMALE";
+        get ordinal(): 2;
+    };
+    static get UNKNOWN(): UserInfoGender & {
+        get name(): "UNKNOWN";
+        get ordinal(): 3;
+    };
+    get name(): "UNSET" | "MALE" | "FEMALE" | "UNKNOWN";
+    get ordinal(): 0 | 1 | 2 | 3;
+    get value(): number;
+    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;
+        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();
+        }
+    }
+}
+export declare class Bot /* implements CoroutineScope */ {
+    private constructor();
+    get uin(): bigint;
+    get uid(): string;
+    get isLoggedIn(): boolean;
+    qrCodeLogin(queryInterval?: bigint): Promise<void>;
+    online(): Promise<void>;
+    offline(): Promise<void>;
+    tryLogin(): Promise<void>;
+    fetchUserInfoByUin(uin: bigint): Promise<BotUserInfo>;
+    fetchUserInfoByUid(uid: string): Promise<BotUserInfo>;
+    fetchFriends(): Promise<Array<BotFriendData>>;
+    fetchGroups(): Promise<Array<BotGroupData>>;
+    fetchGroupMembers(groupUin: bigint): Promise<Array<BotGroupMemberData>>;
+    getFriends(forceUpdate?: boolean): Promise<Array<BotFriend>>;
+    getFriend(uin: bigint, forceUpdate?: boolean): Promise<Nullable<BotFriend>>;
+    getGroups(forceUpdate?: boolean): Promise<Array<BotGroup>>;
+    getGroup(uin: bigint, forceUpdate?: boolean): Promise<Nullable<BotGroup>>;
+    getGroupMembers(groupUin: bigint, forceUpdate?: boolean): Promise<Nullable<Array<BotGroupMember>>>;
+    getGroupMember(groupUin: bigint, memberUin: bigint, forceUpdate?: boolean): Promise<Nullable<BotGroupMember>>;
+    getUinByUid(uid: string): Promise<bigint>;
+    getUidByUin(uin: bigint, mayComeFromGroupUin?: Nullable<bigint>): Promise<string>;
+    getSKey(): Promise<string>;
+    getPSKey(domain: string): Promise<string>;
+    getCookies(domain: string): Promise<KtMap<string, string>>;
+    getCsrfToken(): Promise<number>;
+    sendFriendMessage(friendUin: bigint, build: (p0: BotOutgoingMessageBuilder) => Promise<void>): Promise<BotOutgoingMessageResult>;
+    sendFriendMessageRich(friendUin: bigint, clientSequence: bigint, random: number, build: (p0: BotOutgoingMessageBuilder) => Promise<void>): Promise<BotOutgoingMessageResult>;
+    sendGroupMessage(groupUin: bigint, build: (p0: BotOutgoingMessageBuilder) => Promise<void>): Promise<BotOutgoingMessageResult>;
+    sendGroupMessageRich(groupUin: bigint, clientSequence: bigint, random: number, build: (p0: BotOutgoingMessageBuilder) => Promise<void>): Promise<BotOutgoingMessageResult>;
+    recallFriendMessage(friendUin: bigint, sequence: bigint): Promise<void>;
+    recallGroupMessage(groupUin: bigint, sequence: bigint): Promise<void>;
+    getFriendHistoryMessages(friendUin: bigint, limit: number, startSequence?: Nullable<bigint>): Promise<BotHistoryMessages>;
+    getGroupHistoryMessages(groupUin: bigint, limit: number, startSequence?: Nullable<bigint>): Promise<BotHistoryMessages>;
+    getDownloadUrl(resourceId: string): Promise<string>;
+    getForwardedMessages(resId: string): Promise<Array<BotForwardedMessage>>;
+    markFriendMessagesAsRead(friendUin: bigint, startSequence: bigint, startTime: bigint): Promise<void>;
+    markGroupMessagesAsRead(groupUin: bigint, startSequence: bigint): Promise<void>;
+    sendFriendNudge(friendUin: bigint, isSelf?: boolean): Promise<void>;
+    sendProfileLike(friendUin: bigint, count?: number): Promise<void>;
+    getFriendRequests(isFiltered?: boolean, limit?: number): Promise<Array<BotFriendRequest>>;
+    setFriendRequest(initiatorUid: string, accept: boolean, isFiltered?: boolean): Promise<void>;
+    setGroupName(groupUin: bigint, groupName: string): Promise<void>;
+    setGroupAvatar(groupUin: bigint, imageData: Int8Array): Promise<void>;
+    setGroupMemberCard(groupUin: bigint, memberUin: bigint, card: string): Promise<void>;
+    setGroupMemberSpecialTitle(groupUin: bigint, memberUin: bigint, specialTitle: string): Promise<void>;
+    setGroupMemberAdmin(groupUin: bigint, memberUin: bigint, isAdmin: boolean): Promise<void>;
+    setGroupMemberMute(groupUin: bigint, memberUin: bigint, duration: number): Promise<void>;
+    setGroupWholeMute(groupUin: bigint, isMute: boolean): Promise<void>;
+    kickGroupMember(groupUin: bigint, memberUin: bigint, rejectAddRequest?: boolean, reason?: string): Promise<void>;
+    getGroupAnnouncements(groupUin: bigint): Promise<Array<BotGroupAnnouncement>>;
+    sendGroupAnnouncement(groupUin: bigint, content: string, imageUrl?: Nullable<string>, showEditCard?: boolean, showTipWindow?: boolean, confirmRequired?: boolean): Promise<string>;
+    deleteGroupAnnouncement(groupUin: bigint, announcementId: string): Promise<void>;
+    getGroupEssenceMessages(groupUin: bigint, pageIndex: number, pageSize: number): Promise<BotEssenceMessageResult>;
+    setGroupEssenceMessage(groupUin: bigint, sequence: bigint, isSet: boolean): Promise<void>;
+    quitGroup(groupUin: bigint): Promise<void>;
+    setGroupMessageReaction(groupUin: bigint, sequence: bigint, code: string, isAdd?: boolean): Promise<void>;
+    sendGroupNudge(groupUin: bigint, targetUin: bigint): Promise<void>;
+    getGroupNotifications(startSequence?: Nullable<bigint>, isFiltered?: boolean, count?: number): Promise<JsGroupNotifications>;
+    setGroupRequest(groupUin: bigint, sequence: bigint, eventType: number, accept: boolean, isFiltered?: boolean, reason?: string): Promise<void>;
+    setGroupInvitation(groupUin: bigint, invitationSeq: bigint, accept: boolean): Promise<void>;
+    uploadGroupFile(groupUin: bigint, fileName: string, fileData: Int8Array, parentFolderId?: string): Promise<string>;
+    uploadPrivateFile(friendUin: bigint, fileName: string, fileData: Int8Array): Promise<string>;
+    getPrivateFileDownloadUrl(friendUin: bigint, fileId: string, fileHash: string): Promise<string>;
+    getGroupFileDownloadUrl(groupUin: bigint, fileId: string): Promise<string>;
+    getGroupFileList(groupUin: bigint, targetDirectory?: string, startIndex?: number): Promise<BotGroupFileSystemList>;
+    renameGroupFile(groupUin: bigint, fileId: string, parentFolderId: string, newFileName: string): Promise<void>;
+    moveGroupFile(groupUin: bigint, fileId: string, parentFolderId: string, targetFolderId: string): Promise<void>;
+    deleteGroupFile(groupUin: bigint, fileId: string): Promise<void>;
+    createGroupFolder(groupUin: bigint, folderName: string): Promise<string>;
+    renameGroupFolder(groupUin: bigint, folderId: string, newFolderName: string): Promise<void>;
+    deleteGroupFolder(groupUin: bigint, folderId: string): Promise<void>;
+    onBotOffline(callback: (p0: BotOfflineEvent) => any): void;
+    offBotOffline(callback: (p0: BotOfflineEvent) => any): boolean;
+    onFriendFileUpload(callback: (p0: FriendFileUploadEvent) => any): void;
+    offFriendFileUpload(callback: (p0: FriendFileUploadEvent) => any): boolean;
+    onFriendNudge(callback: (p0: FriendNudgeEvent) => any): void;
+    offFriendNudge(callback: (p0: FriendNudgeEvent) => any): boolean;
+    onFriendRequest(callback: (p0: FriendRequestEvent) => any): void;
+    offFriendRequest(callback: (p0: FriendRequestEvent) => any): boolean;
+    onGroupAdminChange(callback: (p0: GroupAdminChangeEvent) => any): void;
+    offGroupAdminChange(callback: (p0: GroupAdminChangeEvent) => any): boolean;
+    onGroupEssenceMessageChange(callback: (p0: GroupEssenceMessageChangeEvent) => any): void;
+    offGroupEssenceMessageChange(callback: (p0: GroupEssenceMessageChangeEvent) => any): boolean;
+    onGroupFileUpload(callback: (p0: GroupFileUploadEvent) => any): void;
+    offGroupFileUpload(callback: (p0: GroupFileUploadEvent) => any): boolean;
+    onGroupInvitation(callback: (p0: GroupInvitationEvent) => any): void;
+    offGroupInvitation(callback: (p0: GroupInvitationEvent) => any): boolean;
+    onGroupInvitedJoinRequest(callback: (p0: GroupInvitedJoinRequestEvent) => any): void;
+    offGroupInvitedJoinRequest(callback: (p0: GroupInvitedJoinRequestEvent) => any): boolean;
+    onGroupJoinRequest(callback: (p0: GroupJoinRequestEvent) => any): void;
+    offGroupJoinRequest(callback: (p0: GroupJoinRequestEvent) => any): boolean;
+    onGroupMemberDecrease(callback: (p0: GroupMemberDecreaseEvent) => any): void;
+    offGroupMemberDecrease(callback: (p0: GroupMemberDecreaseEvent) => any): boolean;
+    onGroupMemberIncrease(callback: (p0: GroupMemberIncreaseEvent) => any): void;
+    offGroupMemberIncrease(callback: (p0: GroupMemberIncreaseEvent) => any): boolean;
+    onGroupMessageReaction(callback: (p0: GroupMessageReactionEvent) => any): void;
+    offGroupMessageReaction(callback: (p0: GroupMessageReactionEvent) => any): boolean;
+    onGroupMute(callback: (p0: GroupMuteEvent) => any): void;
+    offGroupMute(callback: (p0: GroupMuteEvent) => any): boolean;
+    onGroupNameChange(callback: (p0: GroupNameChangeEvent) => any): void;
+    offGroupNameChange(callback: (p0: GroupNameChangeEvent) => any): boolean;
+    onGroupNudge(callback: (p0: GroupNudgeEvent) => any): void;
+    offGroupNudge(callback: (p0: GroupNudgeEvent) => any): boolean;
+    onGroupWholeMute(callback: (p0: GroupWholeMuteEvent) => any): void;
+    offGroupWholeMute(callback: (p0: GroupWholeMuteEvent) => any): boolean;
+    onMessageReceive(callback: (p0: MessageReceiveEvent) => any): void;
+    offMessageReceive(callback: (p0: MessageReceiveEvent) => any): boolean;
+    onMessageRecall(callback: (p0: MessageRecallEvent) => any): void;
+    offMessageRecall(callback: (p0: MessageRecallEvent) => any): boolean;
+    onQRCodeGenerated(callback: (p0: QRCodeGeneratedEvent) => any): void;
+    offQRCodeGenerated(callback: (p0: QRCodeGeneratedEvent) => any): boolean;
+    onQRCodeStateQuery(callback: (p0: QRCodeStateQueryEvent) => any): void;
+    offQRCodeStateQuery(callback: (p0: QRCodeStateQueryEvent) => any): boolean;
+    onSessionStoreUpdated(callback: (p0: SessionStoreUpdatedEvent) => any): void;
+    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;
+        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();
+        }
+    }
+}
+export declare class BotForwardBlockBuilder {
+    private constructor();
+    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 class BotOutgoingMessageBuilder {
+    private constructor();
+    text(text: string): void;
+    mention(uin: Nullable<bigint>, name: string): void;
+    face(faceId: number, isLarge?: boolean): void;
+    reply(sequence: bigint): void;
+    image(raw: Int8Array, format: ImageFormat, width: number, height: number, subType?: ImageSubType, summary?: string): void;
+    record(rawSilk: Int8Array, duration: bigint): void;
+    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 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 class JsGroupNotifications {
+    constructor(notifications: Array<BotGroupNotification>, nextSequence: Nullable<bigint>);
+    get notifications(): Array<BotGroupNotification>;
+    get nextSequence(): Nullable<bigint>;
+    copy(notifications?: Array<BotGroupNotification>, nextSequence?: Nullable<bigint>): JsGroupNotifications;
+    toString(): string;
+    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 interface SignProvider {
+    sign(cmd: string, seq: number, src: Int8Array): Promise<SignResult>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "org.ntqqrev.acidify.js.SignProvider": unique symbol;
+    };
+}
+export declare class UrlSignProvider implements SignProvider {
+    constructor(scope: CoroutineScope, url: string, httpProxy?: Nullable<string>);
+    get scope(): CoroutineScope;
+    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;
+}