kook-client 1.0.0

package/lib/index.d.ts

@@ -0,0 +1,958 @@
+import * as log4js from 'log4js';
+import { EventEmitter } from 'events';
+import { BinaryLike } from 'crypto';
+import { Stream } from 'node:stream';
+import { AxiosInstance } from 'axios';
+export type Dict<T = any, K extends string | symbol = string> = Record<K, T>;
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "mark" | "off";
+export enum OpCode {
+    Event = 0,// 服务端进行消息推送
+    Hello = 1,// 客户端发送心跳
+    Ping = 2,// 心跳包
+    Pong = 3,// 心跳回包
+    Reconnect = 5,// 需要重连
+    ResumeAck = 6
+}
+export const UnsupportedMethodError: Error;
+export enum ChannelType {
+    Channel = "GROUP",
+    Private = "PERSON",
+    Notice = "BROADCAST"
+}
+export enum NotifyType {
+    Default = 0,
+    All = 1,
+    At = 2,
+    Off = 3
+}
+export abstract class Receiver extends EventEmitter {
+    #private;
+    c: BaseClient;
+    sn: number;
+    buffer: Receiver.EventPacket[];
+    compress?: boolean;
+    protected constructor(c: BaseClient);
+    reset(): void;
+    decryptData(data: string, key: string): string;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+}
+export namespace Receiver {
+    export type Mode = 'webhook' | 'websocket';
+    export type EventPacket<T = any> = {
+        s: OpCode;
+        d: T;
+        sn: number;
+    };
+    /**
+     * 信令[1] HELLO
+     *
+     * **方向：** server->client
+     *
+     * **说明：** 当我们成功连接websocket后，客户端应该在6s内收到该包，否则认为连接超时。
+     *
+     * | 状态码 | 含义 | 备注 |
+     * | - | - | - |
+     * | 0 | 成功 |
+     * | 40100 | 缺少参数 | |
+     * | 40101 | 无效的token | |
+     * | 40102 | token验证失败 | |
+     * | 40103 | token过期 | 需要重新连接 |
+     */
+    export interface HelloPacket {
+        s: OpCode.Hello;
+        d: {
+            code: 0 | 40100 | 40101 | 40102 | 40103;
+            session_id?: string;
+        };
+    }
+    /**
+     * 信令[2] PING
+     *
+     * **方向：** client -> server
+     *
+     * **说明：** 每隔30s(随机-5，+5),将当前的最大 `sn` 传给服务端,客户端应该在6s内收到PONG, 否则心跳超时。
+     *
+     * **参数列表：**
+     *
+     * | 参数 | 描述                              | 类型 | 必传 |
+     * | ---- | --------------------------------- | ---- | ---- |
+     * | sn   | 客户端目前收到的最新的消息 **sn** | number | Y    |
+     */
+    export interface PingEvent {
+        s: OpCode.Ping;
+        sn: number;
+    }
+    export interface PongEvent {
+        s: OpCode.Pong;
+    }
+    /**
+     * 信令[5] RECONNECT
+     * **方向：** server->client
+     *
+     * **说明：** 服务端通知客户端, 代表该连接已失效, 请重新连接。客户端收到后应该主动断开当前连接。
+     *
+     * **注意：**  客户端收到该信令代表因为某些原因导致当前连接已失效, 需要进行以下操作以避免消息丢失.
+     * 1. 重新获取 gateway;
+     * 2. 清空本地的 sn 计数;
+     * 3. 清空本地消息队列.
+     *
+     * | 状态码 | 描述                                    |
+     * | ------------ | --------------------------------------- |
+     * | 40106        | resume 失败, 缺少参数                   |
+     * | 40107        | 当前 `session` 已过期 (resume 失败, PING的sn无效)      |
+     * | 40108        | 无效的 `sn` ,  或 `sn` 已经不存在 (resume 失败, PING的 `sn` 无效) |
+     */
+    export interface ReconnectEvent {
+        s: OpCode.Reconnect;
+        d: {
+            code: 40106 | 40107 | 40108;
+        };
+    }
+    type Construct = new (...args: any[]) => Receiver;
+    export function register(mode: Mode, receiver: Construct): void;
+    export function create(mode: Mode, ...args: any[]): Receiver;
+}
+export class WebhookReceiver extends Receiver {
+    config: WebhookReceiver.Config;
+    constructor(client: BaseClient, config: WebhookReceiver.Config);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export namespace WebhookReceiver {
+    interface Config {
+        token: string;
+        encrypt_key: string;
+        verify_key: string;
+    }
+}
+export class WebsocketReceiver extends Receiver {
+    config: WebsocketReceiver.Config;
+    private _state;
+    private ws;
+    private url;
+    private session_id;
+    private readonly timers;
+    private readonly pingJitterRange;
+    private readonly pingBaseInterval;
+    private readonly helloTimeout;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectBaseDelay;
+    private reconnectTimer;
+    private lastPongTime;
+    private heartbeatTimeout;
+    constructor(client: BaseClient, config: WebsocketReceiver.Config);
+    get state(): WebsocketReceiver.State;
+    private set state(value);
+    get logger(): import("log4js").Logger;
+    private getGatewayUrl;
+    private waitForHello;
+    private sendPing;
+    private setupEventListeners;
+    private cleanup;
+    private getResumeQueryParams;
+    private scheduleReconnect;
+    reconnect(): Promise<void>;
+    private setupNetworkMonitoring;
+    connect(isReconnect?: boolean): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export namespace WebsocketReceiver {
+    interface Config {
+        token: string;
+        compress?: boolean;
+        encrypt_key?: string;
+    }
+    enum State {
+        Initial = 0,
+        PullingGateway = 1,
+        Connecting = 2,
+        Open = 3,
+        Closed = 4,
+        Reconnection = 5
+    }
+}
+function validateCard(card: Segment<'card'>): void;
+type ElementMap = {
+    'plain-text': {
+        content: string;
+        emoji?: boolean;
+    };
+    'kmarkdown': {
+        content: string;
+    };
+    'image': {
+        src: string;
+        alt?: string;
+        size?: 'sm' | 'lg';
+        circle?: boolean;
+        fallbackUrl?: string;
+    };
+    'button': {
+        theme: 'primary' | 'warning' | 'danger' | 'info' | 'success' | 'secondary' | 'none';
+        value: string;
+        click?: 'link' | 'return-val';
+        text: string;
+    };
+    'paragraph': {
+        cols: 1 | 2 | 3;
+        fields: (TextElement | MarkdownElement)[];
+    };
+};
+type ModuleMap = {
+    'header': {
+        text: TextElement;
+    };
+    'section': {
+        text?: TextElement | MarkdownElement | ParagraphElement;
+        mode: 'left' | 'right';
+        accessory?: ImageElement | ButtonElement;
+    };
+    'image-group': {
+        elements: ImageElement[];
+    };
+    'container': {
+        elements: ImageElement[];
+    };
+    'action-group': {
+        elements: ButtonElement[];
+    };
+    'context': {
+        elements: (TextElement | MarkdownElement | ImageElement)[];
+    };
+    'divider': {};
+    'file': {
+        src: string;
+        title: string;
+    };
+    'audio': {
+        src: string;
+        title: string;
+        cover?: string;
+    };
+    'video': {
+        src: string;
+        title: string;
+    };
+    'countdown': {
+        startTime?: number;
+        endTime: number;
+        mode: 'day' | 'hour' | 'second';
+    };
+    'invite': {
+        code: string;
+    };
+};
+type CardMap = {
+    'card': {
+        theme?: 'primary' | 'warning' | 'danger' | 'info' | 'success' | 'secondary' | 'none' | 'invisible';
+        color?: string;
+        size?: 'sm' | 'lg';
+        modules: Module[];
+    };
+};
+export type ElementType = keyof ElementMap;
+export type Element<T extends ElementType = ElementType> = {
+    type: T;
+} & ElementMap[T];
+export type TextElement = Element<'plain-text'>;
+export type MarkdownElement = Element<'kmarkdown'>;
+export type ImageElement = Element<'image'>;
+export type ButtonElement = Element<'button'>;
+export type ParagraphElement = Element<'paragraph'>;
+export type ModuleType = keyof ModuleMap;
+export type Module<T extends ModuleType = ModuleType> = {
+    type: T;
+} & ModuleMap[T];
+export type HeaderModule = Module<'header'>;
+export type SectionModule = Module<'section'>;
+export type ImageModule = Module<'image-group'>;
+export type ContainerModule = Module<'container'>;
+export type ActionModule = Module<'action-group'>;
+export type ContextModule = Module<'context'>;
+export type DividerModule = Module<'divider'>;
+export type FileModule = Module<'file'> | Module<'audio'> | Module<'video'>;
+export type CountdownModule = Module<'countdown'>;
+export type InviteModule = Module<'invite'>;
+export type CardType = keyof CardMap;
+export type Card<T extends CardType = CardType> = {
+    type: T;
+} & CardMap[T];
+export type ElementGenerator = {
+    <T extends ElementType = ElementType>(type: T, data: ElementMap[T]): Element<T>;
+    text(content: string, emoji?: boolean): TextElement;
+    markdown(content: string): MarkdownElement;
+    image(src: string, alt?: string, size?: 'sm' | 'lg', circle?: boolean, fallbackUrl?: string): ImageElement;
+    button(text: string, value: string, theme?: 'primary' | 'warning' | 'danger' | 'info' | 'success' | 'secondary' | 'none', click?: 'link' | 'return-val'): ButtonElement;
+    paragraph(cols: 1 | 2 | 3, fields: (TextElement | MarkdownElement)[]): ParagraphElement;
+};
+export const element: ElementGenerator;
+export type ModuleGenerator = {
+    <T extends ModuleType = ModuleType>(type: T, data: ModuleMap[T]): Module<T>;
+    header(text: TextElement): HeaderModule;
+    section(text?: TextElement | MarkdownElement | ParagraphElement, mode?: 'left' | 'right', accessory?: ImageElement | ButtonElement): SectionModule;
+    image(elements: ImageElement[]): ImageModule;
+    container(elements: ImageElement[]): ContainerModule;
+    action(elements: ButtonElement[]): ActionModule;
+    context(elements: (TextElement | MarkdownElement | ImageElement)[]): ContextModule;
+    divider(): DividerModule;
+    file(src: string, title: string): FileModule;
+    audio(src: string, title: string, cover?: string): FileModule;
+    video(src: string, title: string): FileModule;
+    countdown(endTime: number, mode?: 'day' | 'hour' | 'second', startTime?: number): CountdownModule;
+    invite(code: string): InviteModule;
+};
+export const msgMod: ModuleGenerator;
+type SegmentMap = {
+    'text': {
+        text: string;
+    };
+    'at': {
+        user_id: string;
+    };
+    'card': {
+        theme?: 'primary' | 'warning' | 'danger' | 'info' | 'success' | 'secondary' | 'none' | 'invisible';
+        color?: string;
+        size?: 'sm' | 'lg';
+        modules: Module[];
+    };
+    'image': {
+        url: string;
+        title?: string;
+    };
+    'video': {
+        url: string;
+        title?: string;
+    };
+    'audio': {
+        url: string;
+        title?: string;
+    };
+    'markdown': {
+        text: string;
+    };
+    'reply': {
+        id: string;
+    };
+    'file': {
+        url: string;
+        name?: string;
+        file_type?: string;
+        size?: number;
+    };
+};
+export type SegmentType = keyof SegmentMap;
+export type Segment<T extends SegmentType = SegmentType> = {
+    type: T;
+} & SegmentMap[T];
+export type TextSegment = Segment<'text'>;
+export type AtSegment = Segment<'at'>;
+export type CardSegment = Segment<'card'>;
+export type ImageSegment = Segment<'image'>;
+export type AudioSegment = Segment<'audio'>;
+export type VideoSegment = Segment<'video'>;
+export type MarkdownSegment = Segment<'markdown'>;
+export type ReplySegment = Segment<'reply'>;
+export type FileSegment = Segment<'file'>;
+export type Quotable = {
+    message_id: string;
+};
+export type MessageSegment = AtSegment | TextSegment | ImageSegment | MarkdownSegment | ReplySegment | FileSegment | CardSegment | VideoSegment | AudioSegment;
+export type Sendable = string | MessageSegment | Array<string | MessageSegment>;
+export type SegmentGenerator = {
+    <T extends SegmentType>(type: T, attrs: SegmentMap[T]): Segment<T>;
+    text(text: string): TextSegment;
+    at(user_id: string): AtSegment;
+    card(modules: Module[], options?: {
+        theme?: CardMap['card']['theme'];
+        color?: string;
+        size?: 'sm' | 'lg';
+    }): CardSegment;
+    image(url: string, title?: string): ImageSegment;
+    video(url: string, title?: string): VideoSegment;
+    audio(url: string, title?: string): AudioSegment;
+    markdown(text: string): MarkdownSegment;
+    reply(message_id: string): ReplySegment;
+    file(url: string, name?: string, file_type?: string, size?: number): FileSegment;
+};
+export const segment: SegmentGenerator;
+export { validateCard };
+export const toObject: <T = any>(data: any) => T;
+/** md5 hash */
+export const md5: (data: BinaryLike) => string;
+export function isEmpty<T>(data: T): boolean;
+export function genGroupId(guild_id: string, channel_id: string): string;
+export function parseGroupId(group_id: string): {
+    guild_id: string;
+    channel_id: string;
+};
+export function remove<T>(list: T[], item: T): void;
+/**
+ * create stream from local file
+ * @param filepath {string} filepath
+ */
+export function createLocalFileStream(filepath: string): Promise<Stream>;
+/**
+ * create stream from remote url
+ * @param url {string} remote url
+ */
+export function createRemoteFileStream(url: string): Promise<Stream>;
+export function getFile(file: string | Buffer): Promise<Buffer | Stream>;
+export abstract class Contact {
+    c: Client;
+    protected constructor(c: Client);
+    abstract sendMsg(message: Sendable, quote?: Quotable): Promise<Message.Ret>;
+    abstract updateMsg(message_id: string, newMessage: Sendable, quote?: Quotable): Promise<boolean>;
+    abstract recallMsg(message_id: string): Promise<boolean>;
+    abstract getMsg(message_id: string): Promise<Message>;
+}
+export class User extends Contact {
+    info: User.Info;
+    constructor(c: Client, info: User.Info);
+    sendMsg(message: Sendable, quote?: Quotable): Promise<Message.Ret>;
+    recallMsg(message_id: string): Promise<boolean>;
+    getMsgReactions(message_id: string, emoji?: string): Promise<User.Info[]>;
+    addMsgReaction(message_id: string, emoji: string): Promise<void>;
+    deleteMsgReaction(message_id: string, emoji: string, user_id?: string): Promise<void>;
+    updateMsg(message_id: string, newMessage: Sendable, quote?: Quotable): Promise<boolean>;
+    /**
+     * 获取指定消息之前的聊天历史
+     * @param message_id {string} 消息id 不传则查询最新消息
+     * @param len {number} 获取的聊天历史长度 默认50条
+     */
+    getChatHistory(message_id?: string, len?: number): Promise<Message[]>;
+    getMsg(message_id: string): Promise<Message>;
+    asGuildMember(guild_id: string): GuildMember;
+    asChannelMember(channel_id: string): ChannelMember;
+}
+export namespace User {
+    const map: WeakMap<Info, User>;
+    function as(this: Client, user_id: string, from_id?: never): User;
+    interface Info {
+        /**
+         * 用户id
+         */
+        id: string;
+        /**
+         * 频道id
+         */
+        guild_id?: string;
+        /**
+         * 用户名称
+         */
+        username: string;
+        /**
+         * 用户昵称
+         */
+        nickname: string;
+        /**
+         * 用户名认证数字
+         */
+        identify_num: string;
+        /**
+         * 是否在线
+         */
+        online: boolean;
+        /**
+         * 是否机器人
+         */
+        bot: boolean;
+        /**
+         * 用户状态
+         */
+        status: 1 | 0 | 10;
+        /**
+         * 用户头像
+         */
+        avatar: string;
+        /**
+         * vip用户头像
+         */
+        vip_avatar: string;
+        /**
+         * 是否验证了手机号
+         */
+        mobile_verified: boolean;
+        roles: number[];
+    }
+    enum Permission {
+        normal = 1,
+        admin = 2,
+        owner = 4,
+        channelAdmin = 5
+    }
+}
+export class Channel extends Contact {
+    info: Channel.Info;
+    constructor(c: Client, info: Channel.Info);
+    update(newInfo: Omit<Channel.Info, 'id'>): Promise<void>;
+    delete(): Promise<void>;
+    addUsers(user_ids: string[]): Promise<boolean>;
+    getMsg(message_id: string): Promise<Message>;
+    getUserList(): Promise<User.Info[]>;
+    /**
+     * 获取指定消息之前的聊天历史
+     * @param message_id {string} 消息id 不传则查询最新消息
+     * @param len {number} 获取的聊天历史长度 默认50条
+     */
+    getChatHistory(message_id?: string, len?: number): Promise<Message[]>;
+    sendMsg(message: Sendable, quote?: Quotable): Promise<Message.Ret>;
+    recallMsg(message_id: string): Promise<boolean>;
+    updateMsg(message_id: string, newMessage: Sendable, quote?: Quotable): Promise<boolean>;
+    getMsgReactions(message_id: string, emoji?: string): Promise<User.Info[]>;
+    addMsgReaction(message_id: string, emoji: string): Promise<void>;
+    deleteMsgReaction(message_id: string, emoji: string, user_id?: string): Promise<void>;
+}
+export namespace Channel {
+    const map: WeakMap<Info, Channel>;
+    function as(this: Client, channel_id: string): Channel;
+    interface Info {
+        /**
+         * 频道id
+         */
+        id: string;
+        /**
+         * 创建者id
+         */
+        user_id: string;
+        /**
+         * 频道名称
+         */
+        /**
+         * 父分组频道id
+         */
+        parent_id?: string;
+        name: string;
+        /**
+         * 频道类型
+         */
+        type: ChannelType;
+        /**
+         * 频道排序
+         */
+        level: number;
+        /**
+         * 人数限制
+         */
+        limit_account: number;
+        is_category?: boolean;
+    }
+}
+export class Guild extends Contact {
+    info: Guild.Info;
+    constructor(c: Client, info: Guild.Info);
+    renew(): Promise<void>;
+    quit(): Promise<boolean>;
+    getRoleList(): Promise<Guild.Role[]>;
+    createRole(name: string): Promise<Guild.Role>;
+    updateRole(role_id: string, update_info: Partial<Omit<Guild.Role, 'id'>>): Promise<Guild.Role>;
+    deleteRole(role_id: string): Promise<boolean>;
+    kick(user_id: string): Promise<boolean>;
+    createChannel(channel_info: Omit<Channel.Info, 'id'>): Promise<Channel.Info>;
+    sendMsg(message: Sendable, quote?: Quotable): Promise<Message.Ret>;
+    recallMsg(message_id: string): Promise<boolean>;
+    updateMsg(message_id: string, newMessage: Sendable): Promise<boolean>;
+    getMsg(message_id: string): Promise<Message>;
+}
+export namespace Guild {
+    const map: WeakMap<Info, Guild>;
+    function as(this: Client, guild_id: string): Guild;
+    interface Info {
+        /**
+         * 服务器id
+         */
+        id: string;
+        /**
+         * 服务器名称
+         */
+        name: string;
+        /**
+         * 服务器主题
+         */
+        topic: string;
+        /**
+         * 服务器主人id
+         */
+        user_id: string;
+        /**
+         * icon url
+         */
+        icon: string;
+        /**
+         * 通知类型
+         */
+        notify_type: NotifyType;
+        /**
+         * 默认语音区域
+         */
+        region: string;
+        /**
+         * 是否公开服务器
+         */
+        enable_open: number;
+        /**
+         * 服务器公开id
+         */
+        open_id?: number;
+        /**
+         * 默认频道
+         */
+        default_channel_id?: string;
+        /**
+         * 欢迎频道
+         */
+        welcome_channel_id?: string;
+        /**
+         * 助力数
+         */
+        boost_num?: number;
+        /**
+         * 服务器等级
+         */
+        level?: number;
+    }
+    interface Role {
+        role_id: number;
+        name: string;
+        color: number;
+        position: number;
+        hoist: number;
+        mentionable: number;
+        permissions: number;
+    }
+    enum Permission {
+        Admin = 1,
+        ManageGuild = 2,
+        ViewAdminLog = 4,
+        CreateGuildInvite = 8,
+        ManageInvite = 16,
+        ManageChannel = 32,
+        KickUser = 64,
+        BanUser = 128,
+        ManageCustomFace = 256,
+        UpdateGuildName = 512,
+        ManageRole = 1024,
+        ViewContentOrVoiceChannel = 2048,
+        PublishMsg = 4096,
+        ManageMsg = 8192,
+        UploadFile = 16384,
+        VoiceLink = 32768,
+        ManageVoice = 65536,
+        AtAll = 131072,
+        AddReaction = 262144,
+        FollowReaction = 524288,
+        PassiveLinkVoiceChannel = 1048576,
+        PressKeyTalk = 2097152,
+        FreeTally = 4194304,
+        Talk = 8388608,
+        MuteGuild = 16777216,
+        CloseGuildWheat = 33554432,
+        UpdateOtherUserNickname = 67108864,
+        PlayMusic = 134217728
+    }
+    interface BlackInfo {
+        user_id: string;
+        created_time: number;
+        remark: string;
+        user: User.Info;
+    }
+}
+export abstract class Message {
+    client: Client;
+    message_type: Message.Type;
+    timestamp: number;
+    get self_id(): string;
+    message_id: string;
+    author_id: string;
+    protected constructor(client: Client, payload: Message.Payload);
+    abstract recall(): Promise<boolean>;
+    abstract update(message: Sendable): Promise<boolean>;
+    abstract reply(message: Sendable, quote?: boolean): Promise<Message.Ret>;
+    abstract getReactions(emoji?: string): Promise<User.Info[]>;
+    abstract addReaction(emoji: string): Promise<void>;
+    abstract deleteReaction(emoji: string, user_id?: string): Promise<void>;
+    get author(): User;
+    raw_message: string;
+    message: MessageSegment[];
+    get [Symbol.unscopables](): {
+        client: boolean;
+    };
+    toJSON(): {
+        [k: string]: any;
+    };
+}
+export namespace Message {
+    type Ret = {
+        message_id: string;
+    };
+    type Type = 'private' | 'channel';
+}
+export namespace Message {
+    type Extra = {
+        type: number;
+        guild_id?: string;
+        channel_name?: string;
+        mention: string[];
+        mention_all: boolean;
+        mention_roles: string[];
+        mention_here: boolean;
+        author: User.Info;
+        quote?: Detail;
+        mention_info?: {
+            mention_part: User.Info[];
+            mention_role_part: Guild.Role[];
+        };
+        attachments?: AttachmentInfo;
+        kmarkdown?: MarkdownInfo;
+    };
+    type MarkdownInfo = {
+        raw_content: string;
+        mention_part: string[];
+        mention_role_part: string[];
+    };
+    type AttachmentInfo = {
+        type: string;
+        url: string;
+        name?: string;
+        file_type?: string;
+        size?: number;
+    };
+    type Payload = {
+        channel_type: ChannelType;
+        type: number;
+        target_id: string;
+        author_id: string;
+        content: string;
+        msg_id: string;
+        msg_timestamp: number;
+        nonce?: string;
+        extra: Extra;
+    };
+    interface Detail extends Extra {
+        id: string;
+        type: number;
+        content: string;
+        embeds: Embed[];
+        create_at: number;
+        update_at: number;
+        reactions: ReactionInfo[];
+    }
+    type ReactionInfo = {
+        emoji: {
+            id: string;
+            name: string;
+        };
+        count: number;
+        me: boolean;
+    };
+    type Embed = {
+        type: string;
+        url: string;
+        origin_or: string;
+        av_no: string;
+        iframe_path: string;
+        duration: number;
+        title: string;
+        pic: string;
+    };
+    function convertMessage(content: string, extra: Extra): MessageSegment[];
+    function processMessage(this: Client, message: Sendable, quote?: Quotable): Promise<[string, Quotable?, number?]>;
+}
+export interface MessageEvent {
+    reply(message: Sendable, quote?: boolean): Promise<any>;
+}
+export class PrivateMessageEvent extends Message implements MessageEvent {
+    message_type: 'private';
+    constructor(client: Client, payload: Message.Payload);
+    static fromDetail(client: Client, user_id: string, detail: Message.Detail): PrivateMessageEvent;
+    getReactions(emoji?: string): Promise<User.Info[]>;
+    addReaction(emoji: string): Promise<void>;
+    deleteReaction(emoji: string, user_id?: string): Promise<void>;
+    recall(): Promise<boolean>;
+    update(message: Sendable, quote?: boolean): Promise<boolean>;
+    reply(message: Sendable, quote?: boolean): Promise<Message.Ret>;
+}
+export class ChannelMessageEvent extends Message implements MessageEvent {
+    channel_id: string;
+    message_type: 'channel';
+    channel_name: string;
+    constructor(client: Client, payload: Message.Payload);
+    static fromDetail(client: Client, channel_id: string, detail: Message.Detail): ChannelMessageEvent;
+    get channel(): Channel;
+    recall(): Promise<boolean>;
+    update(message: Sendable): Promise<boolean>;
+    reply(message: Sendable, quote?: boolean): Promise<Message.Ret>;
+    getReactions(emoji?: string): Promise<User.Info[]>;
+    addReaction(emoji: string): Promise<void>;
+    deleteReaction(emoji: string, user_id?: string): Promise<void>;
+}
+export interface EventMap {
+    'message'(e: PrivateMessageEvent | ChannelMessageEvent): void;
+    'message.channel'(e: ChannelMessageEvent): void;
+    'message.private'(e: PrivateMessageEvent): void;
+}
+export class BaseClient extends EventEmitter {
+    request: AxiosInstance;
+    self_id: string;
+    nickname: string;
+    status: number;
+    config: BaseClient.Config;
+    logger: log4js.Logger;
+    receiver: Receiver;
+    private processedEvents;
+    constructor(config: BaseClient.Config);
+    /**
+ * 上传多媒体文件
+ * @param data 文件数据：可以是本地文件(file://)或网络地址(http://)或base64或Buffer
+ * @returns 返回可直接访问的文件URL
+ */
+    uploadMedia(data: string | Buffer): Promise<string>;
+    em(event: string, payload: Dict): void;
+}
+export interface KookClient {
+    on<T extends keyof EventMap>(event: T, callback: EventMap[T]): this;
+    on<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback: (...args: any[]) => void): this;
+    once<T extends keyof EventMap>(event: T, callback: EventMap[T]): this;
+    once<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback: (...args: any[]) => void): this;
+    off<T extends keyof EventMap>(event: T, callback?: EventMap[T]): this;
+    off<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback?: (...args: any[]) => void): this;
+    emit<T extends keyof EventMap>(event: T, ...args: Parameters<EventMap[T]>): boolean;
+    emit<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, ...args: any[]): boolean;
+    addListener<T extends keyof EventMap>(event: T, callback: EventMap[T]): this;
+    addListener<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback: (...args: any[]) => void): this;
+    addListenerOnce<T extends keyof EventMap>(event: T, callback: EventMap[T]): this;
+    addListenerOnce<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback: (...args: any[]) => void): this;
+    removeListener<T extends keyof EventMap>(event: T, callback?: EventMap[T]): this;
+    removeListener<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>, callback?: (...args: any[]) => void): this;
+    removeAllListeners<T extends keyof EventMap>(event: T): this;
+    removeAllListeners<S extends string | symbol>(event: S & Exclude<string | symbol, keyof EventMap>): this;
+}
+export namespace BaseClient {
+    const defaultConfig: Partial<Config>;
+    interface Config {
+        token: string;
+        mode: Receiver.Mode;
+        /**
+         * 验证 token，mode 为 webhook 时必填
+         * */
+        verify_token?: string;
+        /**
+         * 消息加密秘钥，mode 为 webhook 时必填
+         */
+        encrypt_key?: string;
+        /**
+         * 下发数据是否压缩
+         */
+        compress?: boolean;
+        language?: string;
+        timeout?: number;
+        max_retry?: number;
+        data_dir?: string;
+        ignore: 'bot' | 'self';
+        logLevel?: LogLevel;
+    }
+    function getFullTargetId(message: ChannelMessageEvent | PrivateMessageEvent): string;
+}
+export class GuildMember extends User {
+    guild_id: string;
+    constructor(c: Client, guild_id: string, info: User.Info);
+    get guild(): Guild;
+    setNickname(nickname: string): Promise<boolean>;
+    grant(role_id: string): Promise<boolean>;
+    revoke(role_id: string): Promise<boolean>;
+    addToBlackList(remark?: string, del_msg_days?: number): Promise<boolean>;
+    removeFromBlackList(): Promise<boolean>;
+    kick(): Promise<boolean>;
+}
+export namespace GuildMember {
+    const map: WeakMap<User.Info, GuildMember>;
+    function as(this: Client, guild_id: string, user_id: string): GuildMember;
+}
+export class ChannelMember extends User {
+    channel_id: string;
+    constructor(c: Client, channel_id: string, info: User.Info);
+    get channel(): Channel;
+    move(channel_id: string): Promise<boolean>;
+}
+export namespace ChannelMember {
+    const map: WeakMap<User.Info, ChannelMember>;
+    function as(this: Client, channel_id: string, user_id: string): ChannelMember;
+}
+type MemberMap = Map<string, User.Info>;
+type BlackMap = Map<string, Guild.BlackInfo>;
+export class Client extends BaseClient {
+    #private;
+    guilds: Map<string, Guild.Info>;
+    blacklist: Map<string, BlackMap>;
+    channels: Map<string, Channel.Info>;
+    guildMembers: Map<string, MemberMap>;
+    channelMembers: Map<string, MemberMap>;
+    users: Map<string, User.Info>;
+    pickGuild: (guild_id: string) => Guild;
+    pickGuildMember: (guild_id: string, user_id: string) => GuildMember;
+    pickChannel: (channel_id: string) => Channel;
+    pickChannelMember: (channel_id: string, user_id: string) => ChannelMember;
+    pickUser: (user_id: string, from_id?: never) => User;
+    constructor(config: Client.Config);
+    get black_user_nums(): number;
+    getSelfInfo(): Promise<User.Info>;
+    setOnline(): Promise<boolean>;
+    setOffline(): Promise<boolean>;
+    getOnlineStatus(): Promise<{
+        online: boolean;
+        online_os: string[];
+    }>;
+    /**
+     * 获取频道列表
+     */
+    getGuildList(): Promise<Guild.Info[]>;
+    /**
+     * 获取频道信息
+     * @param guild_id
+     */
+    getGuildInfo(guild_id: string): Promise<Guild.Info>;
+    getChannelList(guild_id: string): Promise<Channel.Info[]>;
+    /**
+     * 获取频道成员列表
+     * @param guild_id
+     * @param channel_id
+     */
+    getGuildUserList(guild_id: string, channel_id?: string): Promise<User.Info[]>;
+    getBlacklist(guild_id: string): Promise<Guild.BlackInfo[]>;
+    sendPrivateMsg(user_id: string, message: Sendable, quote?: Quotable): Promise<Message.Ret>;
+    sendChannelMsg(channel_id: string, message: Sendable, quote?: Quotable): Promise<Message.Ret>;
+    getPrivateMsg(user_id: string, message_id: string): Promise<Message>;
+    getChannelMsg(channel_id: string, message_id: string): Promise<Message>;
+    recallPrivateMsg(user_id: string, message_id: string): Promise<boolean>;
+    recallChannelMsg(channel_id: string, message_is: string): Promise<boolean>;
+    getPrivateChatHistory(user_id: string, message_id?: string, len?: number): Promise<Message[]>;
+    getChannelChatHistory(channel_id: string, message_id?: string, len?: number): Promise<Message[]>;
+    init(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export namespace Client {
+    interface Info {
+        id: string;
+        username: string;
+        avatar: string;
+        union_openid?: string;
+        union_user_account?: string;
+    }
+    interface Config extends BaseClient.Config {
+    }
+    const defaultConfig: Partial<Config>;
+}
+export function defineConfig(config: Client.Config): Client.Config;
+export function createClient(config: Client.Config): Client;
+export interface Client extends BaseClient {
+    on<T extends keyof EventMap>(event: T, listener: EventMap[T]): this;
+    on<S extends string | symbol>(event: S & Exclude<S, keyof EventMap>, listener: (...args: any[]) => any): this;
+    emit<T extends keyof EventMap>(event: T, ...args: Parameters<EventMap[T]>): boolean;
+    emit<S extends string | symbol>(event: S & Exclude<S, keyof EventMap>, ...args: any[]): boolean;
+    once<T extends keyof EventMap>(event: T, listener: EventMap[T]): this;
+    once<S extends string | symbol>(event: S & Exclude<S, keyof EventMap>, listener: (...args: any[]) => any): this;
+    off<T extends keyof EventMap>(event: T): this;
+    off<S extends string | symbol>(event: S & Exclude<S, keyof EventMap>): this;
+}