Class Client

Hierarchy (view full)

Constructors

constructor

Properties

bot_user_id config connection? friend_map group_map group_member_map logger prefixed

Methods

CallApi CanSendImage CanSendRecord CleanCache Connect DeleteMsg Disconnect DownloadFile GetCookies GetCredentails GetCsrfToken GetFile GetForwardMsg GetFriendList GetFriendsWithCategory GetGroupList GetGroupMemberList GetLoginInfo GetMsg GetStatus GetStrangerInfo GetVersionInfo Send SetAvatar SetFriendAddRequest SetGroupAddRequest SetMessageEmojiLike SetRestart Start Stop addListener emit eventNames listenerCount listeners off on once removeAllListeners removeListener

Constructors

constructor

Properties

Readonlybot_user_id

bot_user_id: number

Readonlyconfig

config: TClientConfig

Optionalconnection

connection?: WebSocket

friend_map

friend_map: Map<number, TFriendInfo> = ...

group_map

group_map: Map<number, TGroupInfo> = ...

group_member_map

group_member_map: Map<number, Map<number, TGroupMemberInfo>> = ...

logger

logger: ClientLogger

Staticprefixed

prefixed: string | boolean

Methods

CallApi

  • CallApi<T, R>(action, ...args): Promise<ReturnType<R>>

  • CallApi

    Type Parameters

    • T extends keyof IOnebotExports
    • R extends
          | ((params: {
              no_cache?: boolean;
              user_id: number;
          }) => TStrangerInfo)
          | ((params: {
              context: object;
              operation: object;
          }) => void)
          | ((params: {
              auto_escape?: boolean;
              message: TElements;
              user_id: number;
          }) => number)
          | ((params: {
              auto_escape?: boolean;
              group_id: number;
              message: TElements;
          }) => number)
          | ((params: {
              auto_escape?: boolean;
              group_id?: number;
              message: TElements;
              message_type?: "private" | "group";
              user_id?: number;
          }) => number)
          | ((params: {
              message_id: number;
          }) => void)
          | ((params: {
              message_id: number;
          }) => TMessage)
          | ((params: {
              id: string;
          }) => TSegment[])
          | ((params: {
              times?: number;
              user_id: number;
          }) => void)
          | ((params: {
              group_id: number;
              reject_add_request?: boolean;
              user_id: number;
          }) => void)
          | ((params: {
              duration?: number;
              group_id: number;
              user_id: number;
          }) => void)
          | ((params: {
              anonymous?: TAnonymous;
              anonymous_flag?: string;
              duration?: number;
              group_id: number;
          }) => void)
          | ((params: {
              enable?: boolean;
              group_id: number;
          }) => void)
          | ((params: {
              enable?: boolean;
              group_id: number;
              user_id: number;
          }) => void)
          | ((params: {
              enable?: boolean;
              group_id: number;
          }) => void)
          | ((params: {
              card?: string;
              group_id: number;
              user_id: number;
          }) => void)
          | ((params: {
              group_id: number;
              group_name: string;
          }) => void)
          | ((params: {
              group_id: number;
              is_dismiss?: boolean;
          }) => void)
          | ((params: {
              duration?: number;
              group_id: number;
              special_title?: string;
              user_id: number;
          }) => void)
          | ((params: {
              approve?: boolean;
              flag: string;
              remark?: string;
          }) => void)
          | ((params: {
              approve?: boolean;
              flag: string;
              reason?: string;
              sub_type: "add" | "invite";
          }) => void)
          | (() => TLoginInfo)
          | (() => TFriendInfo[])
          | ((params: {
              group_id: number;
              no_cache?: boolean;
          }) => TGroupInfo)
          | (() => TGroupInfo[])
          | ((params: {
              group_id: number;
              no_cache?: boolean;
              user_id: number;
          }) => TGroupMemberInfo)
          | ((params: {
              group_id: number;
          }) => TGroupMemberInfo[])
          | ((params: {
              group_id: number;
              type:
                  | "talkative"
                  | "performer"
                  | "legend"
                  | "strong_newbie"
                  | "emotion"
                  | "all";
          }) => TGroupHonorInfo)
          | ((params: {
              domain?: string;
          }) => {
              cookies: string;
          })
          | (() => {
              token: number;
          })
          | ((params: {
              domain?: string;
          }) => {
              cookies: string;
              token: number;
          })
          | ((params: {
              file: string;
              out_format: string;
          }) => {
              file: string;
          })
          | ((params: {
              file: string;
          }) => {
              file: string;
          })
          | (() => {
              yes: boolean;
          })
          | (() => {
              yes: boolean;
          })
          | (() => TStatus)
          | (() => {
              app_name: string;
              app_version: string;
              protocol_version: string;
          })
          | ((params: {
              delay?: number;
          }) => void)
          | (() => void)
          | ((params: {
              file: string;
          }) => void)
          | (() => TGroupIngoreAddRequestInfo)
          | ((params: {
              file_id: string;
          }) => TFileInfo)
          | ((params: {
              message_id: number;
              user_id: number;
          }) => void)
          | ((params: {
              group_id: number;
              message_id: number;
          }) => void)
          | ((params: {
              emoji_id: number;
              message_id: number;
          }) => void)
          | (() => TFriendWithCategoryInfo)
          | (() => any)
          | ((params: {
              group_id: number;
              messages: TSegment[];
          }) => {
              forward_id: number;
              message_id: number;
          })
          | ((params: {
              messages: TSegment[];
              user_id: number;
          }) => {
              forward_id: number;
              message_id: number;
          })
          | ((params: {
              group_id: number;
              message_seq?: number;
          }) => TSegment[])
          | ((params: {
              file: string;
              folder?: string;
              group_id: number;
              name: string;
          }) => void)
          | ((params: {
              base64?: string;
              headers: string | string[];
              thread_count: number;
              url: string;
          }) => {
              file: string;
          })

    Parameters

    • action: T

      api

    • Rest...args: Parameters<R>

      arguments of api

    Returns Promise<ReturnType<R>>

CanSendImage

  • CanSendImage(): Promise<{
        yes: boolean;
    }>

  • CanSendImage 检查是否可以发送图片

    Returns Promise<{
        yes: boolean;
    }>

CanSendRecord

  • CanSendRecord(): Promise<{
        yes: boolean;
    }>

  • CanSendRecord 检查是否可以发送语音

    Returns Promise<{
        yes: boolean;
    }>

CleanCache

  • CleanCache(): Promise<void>

  • CleanCache 清理缓存

    Returns Promise<void>

    Description

    用于清理积攒了太多的缓存文件。

Connect

DeleteMsg

  • DeleteMsg(message_id): Promise<void>

  • DeleteMsg 撤回消息

    Parameters

    • message_id: number

      消息 ID。

    Returns Promise<void>

Disconnect

DownloadFile

  • DownloadFile(url, thread_count, headers, base64?): Promise<{
        file: string;
    }>

  • DownloadFile (download_file) 下载文件

    Parameters

    • url: string
    • thread_count: number
    • headers: string | string[]
    • Optionalbase64: string

    Returns Promise<{
        file: string;
    }>

GetCookies

  • GetCookies(domain): Promise<{
        cookies: string;
    }>

  • GetCookies 获取Cookies

    Parameters

    • domain: string

      需要获取 cookies 的域名，默认为空。

    Returns Promise<{
        cookies: string;
    }>

GetCredentails

  • GetCredentails(domain?): Promise<{
        cookies: string;
        token: number;
    }>

  • GetCredentials 获取 QQ 相关接口凭证

    Parameters

    • Optionaldomain: string

      需要获取 cookies 的域名，默认为空。

    Returns Promise<{
        cookies: string;
        token: number;
    }>

GetCsrfToken

  • GetCsrfToken(): Promise<{
        token: number;
    }>

  • GetCsrfToken 获取 CSRF Token

    Returns Promise<{
        token: number;
    }>

GetFile

GetForwardMsg

  • GetForwardMsg(id): Promise<TSegment[]>

  • GetForwardMsg 获取合并转发消息

    Parameters

    • id: string

      合并转发 ID。

    Returns Promise<TSegment[]>

GetFriendList

GetFriendsWithCategory

GetGroupList

GetGroupMemberList

GetLoginInfo

GetMsg

GetStatus

GetStrangerInfo

GetVersionInfo

  • GetVersionInfo(): Promise<{
        app_name: string;
        app_version: string;
        protocol_version: string;
    }>

  • GetVersionInfo 获取版本信息

    Returns Promise<{
        app_name: string;
        app_version: string;
        protocol_version: string;
    }>

    本接口仅提供最基础的属性，其他属性见所使用的 Bot 框架文档。

Send

SetAvatar

  • SetAvatar(file): void

  • SetAvatar (set_qq_avatar) 设置群头像

    Parameters

    • file: string

      支持URI格式的绝对路径、网络 URL 以及 Base64 编码。

    Returns void

SetFriendAddRequest

  • SetFriendAddRequest(flag, approve?, remark?): void

  • SetFriendAddRequest 处理好友添加请求

    Parameters

    • flag: string

      加好友请求的 flag（需从上报的数据中获得）。

    • Optionalapprove: boolean

      是否同意请求，默认为 true。

    • Optionalremark: string

      添加后的好友备注（仅在同意时有效），默认为空。

    Returns void

SetGroupAddRequest

  • SetGroupAddRequest(flag, sub_type, approve?, reason?): void

  • SetGroupAddRequest 处理群聊成员添加请求

    Parameters

    • flag: string

      加群请求的 flag（需从上报的数据中获得）。

    • sub_type: "add" | "invite"

      add 或 invite，请求类型（需要和上报消息中的 sub_type 字段相符）。

    • Optionalapprove: boolean

      是否同意请求／邀请，默认为 true。

    • Optionalreason: string

      拒绝理由（仅在拒绝时有效），默认为空。

    Returns void

SetMessageEmojiLike

  • SetMessageEmojiLike(message_id, emoji_id): void

  • Parameters

    • message_id: number

      消息ID。

    • emoji_id: number

      表情ID，取值范围为 [+4, +128563]。

    Returns void

    Deprecated

    SetMessageEmojiLike (set_msg_emoji_like)

SetRestart

  • SetRestart(delay?): Promise<void>

  • SetRestart 重启 OneBot 实现

    Parameters

    • Optionaldelay: number

      要延迟的毫秒数，如果默认情况下无法重启，可以尝试设置延迟为 2000 左右，默认为 0。

    Returns Promise<void>

    Description

    由于重启 OneBot 实现同时需要重启 API 服务，这意味着当前的 API 请求会被中断，因此需要异步地重启，接口返回的 status 是 async。

Start

Stop

  • Stop(): void

  • Disconnect to the websocket server.

    Returns void

addListener

  • addListener<T>(event, fn, context?): this

  • Type Parameters

    • T extends
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close"

    Parameters

    • event: T
    • fn: ((...args: ArgumentMap<{
          message(event: TPrivateMessageEvent | TGroupMemberSender): void;
      } & {
          message.private(event: TPrivateMessageEvent): void;
          message.private.friend(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "friend";
          }): void;
          message.private.group(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "group";
          }): void;
          message.private.other(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "other";
          }): void;
      } & {
          message.group(event: TGroupMessageEvent): void;
          message.group.anonymous(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "anonymous";
          }): void;
          message.group.normal(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "normal";
          }): void;
          message.group.notice(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "notice";
          }): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent
              | TFriendAddEvent
              | TFriendMessageRecallevent): void;
      } & {
          notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
          notice.friend_add(event: TFriendAddEvent): void;
          notice.friend_recall(event: TFriendMessageRecallevent): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent): void;
          notice.group_admin(event: TGroupAdminChangeEvent): void;
          notice.group_ban(event: TGroupMuteEvent): void;
          notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
          notice.group_increase(event: TGroupMemberIncreaseEvent): void;
          notice.group_recall(event: TGroupMessageRecallEvent): void;
          notice.group_upload(event: TGroupFileUploadEvent): void;
      } & {
          request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
      } & {
          request(event: TFriendAddInviteEvent): void;
          request.friend(event: TFriendAddInviteEvent): void;
      } & {
          request(event: TMemberAddOrInviteEvent): void;
          request.group.add(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "add";
          }): void;
          request.group.invite(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "invite";
          }): void;
      } & TBaseClientEventMap>[Extract<T,
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close">]) => void)
        • (...args): void

        • Parameters

          • Rest...args: ArgumentMap<{
                message(event: TPrivateMessageEvent | TGroupMemberSender): void;
            } & {
                message.private(event: TPrivateMessageEvent): void;
                message.private.friend(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "friend";
                }): void;
                message.private.group(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "group";
                }): void;
                message.private.other(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "other";
                }): void;
            } & {
                message.group(event: TGroupMessageEvent): void;
                message.group.anonymous(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "anonymous";
                }): void;
                message.group.normal(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "normal";
                }): void;
                message.group.notice(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "notice";
                }): void;
            } & {
                notice(event:
                    | TGroupFileUploadEvent
                    | TGroupAdminChangeEvent
                    | TGroupMemberDecreaseEvent
                    | TGroupMemberIncreaseEvent
                    | TGroupMuteEvent
                    | TGroupMessageRecallEvent
                    | TFriendAddEvent
                    | TFriendMessageRecallevent): void;
            } & {
                notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
                notice.friend_add(event: TFriendAddEvent): void;
                notice.friend_recall(event: TFriendMessageRecallevent): void;
            } & {
                notice(event:
                    | TGroupFileUploadEvent
                    | TGroupAdminChangeEvent
                    | TGroupMemberDecreaseEvent
                    | TGroupMemberIncreaseEvent
                    | TGroupMuteEvent
                    | TGroupMessageRecallEvent): void;
                notice.group_admin(event: TGroupAdminChangeEvent): void;
                notice.group_ban(event: TGroupMuteEvent): void;
                notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
                notice.group_increase(event: TGroupMemberIncreaseEvent): void;
                notice.group_recall(event: TGroupMessageRecallEvent): void;
                notice.group_upload(event: TGroupFileUploadEvent): void;
            } & {
                request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
            } & {
                request(event: TFriendAddInviteEvent): void;
                request.friend(event: TFriendAddInviteEvent): void;
            } & {
                request(event: TMemberAddOrInviteEvent): void;
                request.group.add(event: TBaseEvent & {
                    comment: string;
                    flag: string;
                    post_type: "request";
                    request_type: "group" | "friend";
                    user_id: number;
                } & {
                    group_id: number;
                    request_type: "group";
                    sub_type: "add" | "invite";
                    approve(isApprove?: boolean, reason?: string): void;
                } & {
                    sub_type: "add";
                }): void;
                request.group.invite(event: TBaseEvent & {
                    comment: string;
                    flag: string;
                    post_type: "request";
                    request_type: "group" | "friend";
                    user_id: number;
                } & {
                    group_id: number;
                    request_type: "group";
                    sub_type: "add" | "invite";
                    approve(isApprove?: boolean, reason?: string): void;
                } & {
                    sub_type: "invite";
                }): void;
            } & TBaseClientEventMap>[Extract<T,
                | "message.private"
                | "message.private.friend"
                | "message.private.group"
                | "message.private.other"
                | "message.group"
                | "message.group.normal"
                | "message.group.anonymous"
                | "message.group.notice"
                | "notice"
                | "notice.friend_add"
                | "notice.friend_recall"
                | "notice.group_upload"
                | "notice.group_admin"
                | "notice.group_decrease"
                | "notice.group_increase"
                | "notice.group_ban"
                | "notice.group_recall"
                | "request"
                | "request.friend"
                | "request.group.add"
                | "request.group.invite"
                | "data"
                | "message"
                | "error"
                | "open"
                | "close">]

          Returns void

    • Optionalcontext: any

    Returns this

emit

  • emit<T>(event, ...args): boolean

  • Calls each of the listeners registered for a given event.

    Type Parameters

    • T extends
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close"

    Parameters

    • event: T
    • Rest...args: ArgumentMap<{
          message(event: TPrivateMessageEvent | TGroupMemberSender): void;
      } & {
          message.private(event: TPrivateMessageEvent): void;
          message.private.friend(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "friend";
          }): void;
          message.private.group(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "group";
          }): void;
          message.private.other(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "other";
          }): void;
      } & {
          message.group(event: TGroupMessageEvent): void;
          message.group.anonymous(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "anonymous";
          }): void;
          message.group.normal(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "normal";
          }): void;
          message.group.notice(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "notice";
          }): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent
              | TFriendAddEvent
              | TFriendMessageRecallevent): void;
      } & {
          notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
          notice.friend_add(event: TFriendAddEvent): void;
          notice.friend_recall(event: TFriendMessageRecallevent): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent): void;
          notice.group_admin(event: TGroupAdminChangeEvent): void;
          notice.group_ban(event: TGroupMuteEvent): void;
          notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
          notice.group_increase(event: TGroupMemberIncreaseEvent): void;
          notice.group_recall(event: TGroupMessageRecallEvent): void;
          notice.group_upload(event: TGroupFileUploadEvent): void;
      } & {
          request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
      } & {
          request(event: TFriendAddInviteEvent): void;
          request.friend(event: TFriendAddInviteEvent): void;
      } & {
          request(event: TMemberAddOrInviteEvent): void;
          request.group.add(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "add";
          }): void;
          request.group.invite(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "invite";
          }): void;
      } & TBaseClientEventMap>[Extract<T,
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close">]

    Returns boolean

eventNames

  • eventNames(): (
        | "message.private"
        | "message.private.friend"
        | "message.private.group"
        | "message.private.other"
        | "message.group"
        | "message.group.normal"
        | "message.group.anonymous"
        | "message.group.notice"
        | "notice"
        | "notice.friend_add"
        | "notice.friend_recall"
        | "notice.group_upload"
        | "notice.group_admin"
        | "notice.group_decrease"
        | "notice.group_increase"
        | "notice.group_ban"
        | "notice.group_recall"
        | "request"
        | "request.friend"
        | "request.group.add"
        | "request.group.invite"
        | "data"
        | "message"
        | "error"
        | "open"
        | "close")[]

  • Return an array listing the events for which the emitter has registered listeners.

    Returns (
        | "message.private"
        | "message.private.friend"
        | "message.private.group"
        | "message.private.other"
        | "message.group"
        | "message.group.normal"
        | "message.group.anonymous"
        | "message.group.notice"
        | "notice"
        | "notice.friend_add"
        | "notice.friend_recall"
        | "notice.group_upload"
        | "notice.group_admin"
        | "notice.group_decrease"
        | "notice.group_increase"
        | "notice.group_ban"
        | "notice.group_recall"
        | "request"
        | "request.friend"
        | "request.group.add"
        | "request.group.invite"
        | "data"
        | "message"
        | "error"
        | "open"
        | "close")[]

listenerCount

  • listenerCount(event): number

  • Return the number of listeners listening to a given event.

    Parameters

    • event:
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close"

    Returns number

listeners

  • listeners<T>(event): ((...args: ArgumentMap<{
        message(event: TPrivateMessageEvent | TGroupMemberSender): void;
    } & {
        message.private(event: TPrivateMessageEvent): void;
        message.private.friend(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            message_type: "private";
            sender: TStrangerInfo;
            sub_type: "group" | "friend" | "other";
        } & {
            sub_type: "friend";
        }): void;
        message.private.group(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            message_type: "private";
            sender: TStrangerInfo;
            sub_type: "group" | "friend" | "other";
        } & {
            sub_type: "group";
        }): void;
        message.private.other(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            message_type: "private";
            sender: TStrangerInfo;
            sub_type: "group" | "friend" | "other";
        } & {
            sub_type: "other";
        }): void;
    } & {
        message.group(event: TGroupMessageEvent): void;
        message.group.anonymous(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            anonymous: null | TAnonymous;
            group_id: number;
            message_type: "group";
            sender: TGroupMemberSender;
            sub_type: "notice" | "normal" | "anonymous";
            kick(): void;
            mute(ban_duration?: number): void;
            recall(): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
        } & {
            sub_type: "anonymous";
        }): void;
        message.group.normal(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            anonymous: null | TAnonymous;
            group_id: number;
            message_type: "group";
            sender: TGroupMemberSender;
            sub_type: "notice" | "normal" | "anonymous";
            kick(): void;
            mute(ban_duration?: number): void;
            recall(): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
        } & {
            sub_type: "normal";
        }): void;
        message.group.notice(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            anonymous: null | TAnonymous;
            group_id: number;
            message_type: "group";
            sender: TGroupMemberSender;
            sub_type: "notice" | "normal" | "anonymous";
            kick(): void;
            mute(ban_duration?: number): void;
            recall(): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
        } & {
            sub_type: "notice";
        }): void;
    } & {
        notice(event:
            | TGroupFileUploadEvent
            | TGroupAdminChangeEvent
            | TGroupMemberDecreaseEvent
            | TGroupMemberIncreaseEvent
            | TGroupMuteEvent
            | TGroupMessageRecallEvent
            | TFriendAddEvent
            | TFriendMessageRecallevent): void;
    } & {
        notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
        notice.friend_add(event: TFriendAddEvent): void;
        notice.friend_recall(event: TFriendMessageRecallevent): void;
    } & {
        notice(event:
            | TGroupFileUploadEvent
            | TGroupAdminChangeEvent
            | TGroupMemberDecreaseEvent
            | TGroupMemberIncreaseEvent
            | TGroupMuteEvent
            | TGroupMessageRecallEvent): void;
        notice.group_admin(event: TGroupAdminChangeEvent): void;
        notice.group_ban(event: TGroupMuteEvent): void;
        notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
        notice.group_increase(event: TGroupMemberIncreaseEvent): void;
        notice.group_recall(event: TGroupMessageRecallEvent): void;
        notice.group_upload(event: TGroupFileUploadEvent): void;
    } & {
        request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
    } & {
        request(event: TFriendAddInviteEvent): void;
        request.friend(event: TFriendAddInviteEvent): void;
    } & {
        request(event: TMemberAddOrInviteEvent): void;
        request.group.add(event: TBaseEvent & {
            comment: string;
            flag: string;
            post_type: "request";
            request_type: "group" | "friend";
            user_id: number;
        } & {
            group_id: number;
            request_type: "group";
            sub_type: "add" | "invite";
            approve(isApprove?: boolean, reason?: string): void;
        } & {
            sub_type: "add";
        }): void;
        request.group.invite(event: TBaseEvent & {
            comment: string;
            flag: string;
            post_type: "request";
            request_type: "group" | "friend";
            user_id: number;
        } & {
            group_id: number;
            request_type: "group";
            sub_type: "add" | "invite";
            approve(isApprove?: boolean, reason?: string): void;
        } & {
            sub_type: "invite";
        }): void;
    } & TBaseClientEventMap>[Extract<T,
        | "message.private"
        | "message.private.friend"
        | "message.private.group"
        | "message.private.other"
        | "message.group"
        | "message.group.normal"
        | "message.group.anonymous"
        | "message.group.notice"
        | "notice"
        | "notice.friend_add"
        | "notice.friend_recall"
        | "notice.group_upload"
        | "notice.group_admin"
        | "notice.group_decrease"
        | "notice.group_increase"
        | "notice.group_ban"
        | "notice.group_recall"
        | "request"
        | "request.friend"
        | "request.group.add"
        | "request.group.invite"
        | "data"
        | "message"
        | "error"
        | "open"
        | "close">]) => void)[]

  • Return the listeners registered for a given event.

    Type Parameters

    • T extends
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close"

    Parameters

    • event: T

    Returns ((...args: ArgumentMap<{
        message(event: TPrivateMessageEvent | TGroupMemberSender): void;
    } & {
        message.private(event: TPrivateMessageEvent): void;
        message.private.friend(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            message_type: "private";
            sender: TStrangerInfo;
            sub_type: "group" | "friend" | "other";
        } & {
            sub_type: "friend";
        }): void;
        message.private.group(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            message_type: "private";
            sender: TStrangerInfo;
            sub_type: "group" | "friend" | "other";
        } & {
            sub_type: "group";
        }): void;
        message.private.other(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            message_type: "private";
            sender: TStrangerInfo;
            sub_type: "group" | "friend" | "other";
        } & {
            sub_type: "other";
        }): void;
    } & {
        message.group(event: TGroupMessageEvent): void;
        message.group.anonymous(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            anonymous: null | TAnonymous;
            group_id: number;
            message_type: "group";
            sender: TGroupMemberSender;
            sub_type: "notice" | "normal" | "anonymous";
            kick(): void;
            mute(ban_duration?: number): void;
            recall(): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
        } & {
            sub_type: "anonymous";
        }): void;
        message.group.normal(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            anonymous: null | TAnonymous;
            group_id: number;
            message_type: "group";
            sender: TGroupMemberSender;
            sub_type: "notice" | "normal" | "anonymous";
            kick(): void;
            mute(ban_duration?: number): void;
            recall(): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
        } & {
            sub_type: "normal";
        }): void;
        message.group.notice(event: TBaseEvent & {
            font: number;
            message: TElements;
            message_id: number;
            message_type: "private" | "group";
            post_type: "message";
            raw_message: string;
            sub_type: string;
            user_id: number;
            forwardMessage(target_id: number): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
            replyViaEmoji(emoji_id: number): void;
        } & {
            anonymous: null | TAnonymous;
            group_id: number;
            message_type: "group";
            sender: TGroupMemberSender;
            sub_type: "notice" | "normal" | "anonymous";
            kick(): void;
            mute(ban_duration?: number): void;
            recall(): void;
            reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
        } & {
            sub_type: "notice";
        }): void;
    } & {
        notice(event:
            | TGroupFileUploadEvent
            | TGroupAdminChangeEvent
            | TGroupMemberDecreaseEvent
            | TGroupMemberIncreaseEvent
            | TGroupMuteEvent
            | TGroupMessageRecallEvent
            | TFriendAddEvent
            | TFriendMessageRecallevent): void;
    } & {
        notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
        notice.friend_add(event: TFriendAddEvent): void;
        notice.friend_recall(event: TFriendMessageRecallevent): void;
    } & {
        notice(event:
            | TGroupFileUploadEvent
            | TGroupAdminChangeEvent
            | TGroupMemberDecreaseEvent
            | TGroupMemberIncreaseEvent
            | TGroupMuteEvent
            | TGroupMessageRecallEvent): void;
        notice.group_admin(event: TGroupAdminChangeEvent): void;
        notice.group_ban(event: TGroupMuteEvent): void;
        notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
        notice.group_increase(event: TGroupMemberIncreaseEvent): void;
        notice.group_recall(event: TGroupMessageRecallEvent): void;
        notice.group_upload(event: TGroupFileUploadEvent): void;
    } & {
        request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
    } & {
        request(event: TFriendAddInviteEvent): void;
        request.friend(event: TFriendAddInviteEvent): void;
    } & {
        request(event: TMemberAddOrInviteEvent): void;
        request.group.add(event: TBaseEvent & {
            comment: string;
            flag: string;
            post_type: "request";
            request_type: "group" | "friend";
            user_id: number;
        } & {
            group_id: number;
            request_type: "group";
            sub_type: "add" | "invite";
            approve(isApprove?: boolean, reason?: string): void;
        } & {
            sub_type: "add";
        }): void;
        request.group.invite(event: TBaseEvent & {
            comment: string;
            flag: string;
            post_type: "request";
            request_type: "group" | "friend";
            user_id: number;
        } & {
            group_id: number;
            request_type: "group";
            sub_type: "add" | "invite";
            approve(isApprove?: boolean, reason?: string): void;
        } & {
            sub_type: "invite";
        }): void;
    } & TBaseClientEventMap>[Extract<T,
        | "message.private"
        | "message.private.friend"
        | "message.private.group"
        | "message.private.other"
        | "message.group"
        | "message.group.normal"
        | "message.group.anonymous"
        | "message.group.notice"
        | "notice"
        | "notice.friend_add"
        | "notice.friend_recall"
        | "notice.group_upload"
        | "notice.group_admin"
        | "notice.group_decrease"
        | "notice.group_increase"
        | "notice.group_ban"
        | "notice.group_recall"
        | "request"
        | "request.friend"
        | "request.group.add"
        | "request.group.invite"
        | "data"
        | "message"
        | "error"
        | "open"
        | "close">]) => void)[]

off

  • off<T>(event, fn?, context?, once?): this

  • Type Parameters

    • T extends
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close"

    Parameters

    • event: T
    • Optionalfn: ((...args: ArgumentMap<{
          message(event: TPrivateMessageEvent | TGroupMemberSender): void;
      } & {
          message.private(event: TPrivateMessageEvent): void;
          message.private.friend(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "friend";
          }): void;
          message.private.group(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "group";
          }): void;
          message.private.other(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "other";
          }): void;
      } & {
          message.group(event: TGroupMessageEvent): void;
          message.group.anonymous(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "anonymous";
          }): void;
          message.group.normal(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "normal";
          }): void;
          message.group.notice(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "notice";
          }): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent
              | TFriendAddEvent
              | TFriendMessageRecallevent): void;
      } & {
          notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
          notice.friend_add(event: TFriendAddEvent): void;
          notice.friend_recall(event: TFriendMessageRecallevent): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent): void;
          notice.group_admin(event: TGroupAdminChangeEvent): void;
          notice.group_ban(event: TGroupMuteEvent): void;
          notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
          notice.group_increase(event: TGroupMemberIncreaseEvent): void;
          notice.group_recall(event: TGroupMessageRecallEvent): void;
          notice.group_upload(event: TGroupFileUploadEvent): void;
      } & {
          request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
      } & {
          request(event: TFriendAddInviteEvent): void;
          request.friend(event: TFriendAddInviteEvent): void;
      } & {
          request(event: TMemberAddOrInviteEvent): void;
          request.group.add(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "add";
          }): void;
          request.group.invite(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "invite";
          }): void;
      } & TBaseClientEventMap>[Extract<T,
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close">]) => void)
        • (...args): void

        • Parameters

          • Rest...args: ArgumentMap<{
                message(event: TPrivateMessageEvent | TGroupMemberSender): void;
            } & {
                message.private(event: TPrivateMessageEvent): void;
                message.private.friend(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "friend";
                }): void;
                message.private.group(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "group";
                }): void;
                message.private.other(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "other";
                }): void;
            } & {
                message.group(event: TGroupMessageEvent): void;
                message.group.anonymous(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "anonymous";
                }): void;
                message.group.normal(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "normal";
                }): void;
                message.group.notice(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "notice";
                }): void;
            } & {
                notice(event:
                    | TGroupFileUploadEvent
                    | TGroupAdminChangeEvent
                    | TGroupMemberDecreaseEvent
                    | TGroupMemberIncreaseEvent
                    | TGroupMuteEvent
                    | TGroupMessageRecallEvent
                    | TFriendAddEvent
                    | TFriendMessageRecallevent): void;
            } & {
                notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
                notice.friend_add(event: TFriendAddEvent): void;
                notice.friend_recall(event: TFriendMessageRecallevent): void;
            } & {
                notice(event:
                    | TGroupFileUploadEvent
                    | TGroupAdminChangeEvent
                    | TGroupMemberDecreaseEvent
                    | TGroupMemberIncreaseEvent
                    | TGroupMuteEvent
                    | TGroupMessageRecallEvent): void;
                notice.group_admin(event: TGroupAdminChangeEvent): void;
                notice.group_ban(event: TGroupMuteEvent): void;
                notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
                notice.group_increase(event: TGroupMemberIncreaseEvent): void;
                notice.group_recall(event: TGroupMessageRecallEvent): void;
                notice.group_upload(event: TGroupFileUploadEvent): void;
            } & {
                request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
            } & {
                request(event: TFriendAddInviteEvent): void;
                request.friend(event: TFriendAddInviteEvent): void;
            } & {
                request(event: TMemberAddOrInviteEvent): void;
                request.group.add(event: TBaseEvent & {
                    comment: string;
                    flag: string;
                    post_type: "request";
                    request_type: "group" | "friend";
                    user_id: number;
                } & {
                    group_id: number;
                    request_type: "group";
                    sub_type: "add" | "invite";
                    approve(isApprove?: boolean, reason?: string): void;
                } & {
                    sub_type: "add";
                }): void;
                request.group.invite(event: TBaseEvent & {
                    comment: string;
                    flag: string;
                    post_type: "request";
                    request_type: "group" | "friend";
                    user_id: number;
                } & {
                    group_id: number;
                    request_type: "group";
                    sub_type: "add" | "invite";
                    approve(isApprove?: boolean, reason?: string): void;
                } & {
                    sub_type: "invite";
                }): void;
            } & TBaseClientEventMap>[Extract<T,
                | "message.private"
                | "message.private.friend"
                | "message.private.group"
                | "message.private.other"
                | "message.group"
                | "message.group.normal"
                | "message.group.anonymous"
                | "message.group.notice"
                | "notice"
                | "notice.friend_add"
                | "notice.friend_recall"
                | "notice.group_upload"
                | "notice.group_admin"
                | "notice.group_decrease"
                | "notice.group_increase"
                | "notice.group_ban"
                | "notice.group_recall"
                | "request"
                | "request.friend"
                | "request.group.add"
                | "request.group.invite"
                | "data"
                | "message"
                | "error"
                | "open"
                | "close">]

          Returns void

    • Optionalcontext: any
    • Optionalonce: boolean

    Returns this

on

  • on<T>(event, fn, context?): this

  • Add a listener for a given event.

    Type Parameters

    • T extends
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close"

    Parameters

    • event: T
    • fn: ((...args: ArgumentMap<{
          message(event: TPrivateMessageEvent | TGroupMemberSender): void;
      } & {
          message.private(event: TPrivateMessageEvent): void;
          message.private.friend(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "friend";
          }): void;
          message.private.group(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "group";
          }): void;
          message.private.other(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "other";
          }): void;
      } & {
          message.group(event: TGroupMessageEvent): void;
          message.group.anonymous(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "anonymous";
          }): void;
          message.group.normal(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "normal";
          }): void;
          message.group.notice(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "notice";
          }): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent
              | TFriendAddEvent
              | TFriendMessageRecallevent): void;
      } & {
          notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
          notice.friend_add(event: TFriendAddEvent): void;
          notice.friend_recall(event: TFriendMessageRecallevent): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent): void;
          notice.group_admin(event: TGroupAdminChangeEvent): void;
          notice.group_ban(event: TGroupMuteEvent): void;
          notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
          notice.group_increase(event: TGroupMemberIncreaseEvent): void;
          notice.group_recall(event: TGroupMessageRecallEvent): void;
          notice.group_upload(event: TGroupFileUploadEvent): void;
      } & {
          request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
      } & {
          request(event: TFriendAddInviteEvent): void;
          request.friend(event: TFriendAddInviteEvent): void;
      } & {
          request(event: TMemberAddOrInviteEvent): void;
          request.group.add(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "add";
          }): void;
          request.group.invite(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "invite";
          }): void;
      } & TBaseClientEventMap>[Extract<T,
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close">]) => void)
        • (...args): void

        • Parameters

          • Rest...args: ArgumentMap<{
                message(event: TPrivateMessageEvent | TGroupMemberSender): void;
            } & {
                message.private(event: TPrivateMessageEvent): void;
                message.private.friend(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "friend";
                }): void;
                message.private.group(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "group";
                }): void;
                message.private.other(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "other";
                }): void;
            } & {
                message.group(event: TGroupMessageEvent): void;
                message.group.anonymous(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "anonymous";
                }): void;
                message.group.normal(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "normal";
                }): void;
                message.group.notice(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "notice";
                }): void;
            } & {
                notice(event:
                    | TGroupFileUploadEvent
                    | TGroupAdminChangeEvent
                    | TGroupMemberDecreaseEvent
                    | TGroupMemberIncreaseEvent
                    | TGroupMuteEvent
                    | TGroupMessageRecallEvent
                    | TFriendAddEvent
                    | TFriendMessageRecallevent): void;
            } & {
                notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
                notice.friend_add(event: TFriendAddEvent): void;
                notice.friend_recall(event: TFriendMessageRecallevent): void;
            } & {
                notice(event:
                    | TGroupFileUploadEvent
                    | TGroupAdminChangeEvent
                    | TGroupMemberDecreaseEvent
                    | TGroupMemberIncreaseEvent
                    | TGroupMuteEvent
                    | TGroupMessageRecallEvent): void;
                notice.group_admin(event: TGroupAdminChangeEvent): void;
                notice.group_ban(event: TGroupMuteEvent): void;
                notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
                notice.group_increase(event: TGroupMemberIncreaseEvent): void;
                notice.group_recall(event: TGroupMessageRecallEvent): void;
                notice.group_upload(event: TGroupFileUploadEvent): void;
            } & {
                request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
            } & {
                request(event: TFriendAddInviteEvent): void;
                request.friend(event: TFriendAddInviteEvent): void;
            } & {
                request(event: TMemberAddOrInviteEvent): void;
                request.group.add(event: TBaseEvent & {
                    comment: string;
                    flag: string;
                    post_type: "request";
                    request_type: "group" | "friend";
                    user_id: number;
                } & {
                    group_id: number;
                    request_type: "group";
                    sub_type: "add" | "invite";
                    approve(isApprove?: boolean, reason?: string): void;
                } & {
                    sub_type: "add";
                }): void;
                request.group.invite(event: TBaseEvent & {
                    comment: string;
                    flag: string;
                    post_type: "request";
                    request_type: "group" | "friend";
                    user_id: number;
                } & {
                    group_id: number;
                    request_type: "group";
                    sub_type: "add" | "invite";
                    approve(isApprove?: boolean, reason?: string): void;
                } & {
                    sub_type: "invite";
                }): void;
            } & TBaseClientEventMap>[Extract<T,
                | "message.private"
                | "message.private.friend"
                | "message.private.group"
                | "message.private.other"
                | "message.group"
                | "message.group.normal"
                | "message.group.anonymous"
                | "message.group.notice"
                | "notice"
                | "notice.friend_add"
                | "notice.friend_recall"
                | "notice.group_upload"
                | "notice.group_admin"
                | "notice.group_decrease"
                | "notice.group_increase"
                | "notice.group_ban"
                | "notice.group_recall"
                | "request"
                | "request.friend"
                | "request.group.add"
                | "request.group.invite"
                | "data"
                | "message"
                | "error"
                | "open"
                | "close">]

          Returns void

    • Optionalcontext: any

    Returns this

once

  • once<T>(event, fn, context?): this

  • Add a one-time listener for a given event.

    Type Parameters

    • T extends
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close"

    Parameters

    • event: T
    • fn: ((...args: ArgumentMap<{
          message(event: TPrivateMessageEvent | TGroupMemberSender): void;
      } & {
          message.private(event: TPrivateMessageEvent): void;
          message.private.friend(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "friend";
          }): void;
          message.private.group(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "group";
          }): void;
          message.private.other(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "other";
          }): void;
      } & {
          message.group(event: TGroupMessageEvent): void;
          message.group.anonymous(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "anonymous";
          }): void;
          message.group.normal(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "normal";
          }): void;
          message.group.notice(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "notice";
          }): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent
              | TFriendAddEvent
              | TFriendMessageRecallevent): void;
      } & {
          notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
          notice.friend_add(event: TFriendAddEvent): void;
          notice.friend_recall(event: TFriendMessageRecallevent): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent): void;
          notice.group_admin(event: TGroupAdminChangeEvent): void;
          notice.group_ban(event: TGroupMuteEvent): void;
          notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
          notice.group_increase(event: TGroupMemberIncreaseEvent): void;
          notice.group_recall(event: TGroupMessageRecallEvent): void;
          notice.group_upload(event: TGroupFileUploadEvent): void;
      } & {
          request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
      } & {
          request(event: TFriendAddInviteEvent): void;
          request.friend(event: TFriendAddInviteEvent): void;
      } & {
          request(event: TMemberAddOrInviteEvent): void;
          request.group.add(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "add";
          }): void;
          request.group.invite(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "invite";
          }): void;
      } & TBaseClientEventMap>[Extract<T,
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close">]) => void)
        • (...args): void

        • Parameters

          • Rest...args: ArgumentMap<{
                message(event: TPrivateMessageEvent | TGroupMemberSender): void;
            } & {
                message.private(event: TPrivateMessageEvent): void;
                message.private.friend(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "friend";
                }): void;
                message.private.group(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "group";
                }): void;
                message.private.other(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "other";
                }): void;
            } & {
                message.group(event: TGroupMessageEvent): void;
                message.group.anonymous(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "anonymous";
                }): void;
                message.group.normal(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "normal";
                }): void;
                message.group.notice(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "notice";
                }): void;
            } & {
                notice(event:
                    | TGroupFileUploadEvent
                    | TGroupAdminChangeEvent
                    | TGroupMemberDecreaseEvent
                    | TGroupMemberIncreaseEvent
                    | TGroupMuteEvent
                    | TGroupMessageRecallEvent
                    | TFriendAddEvent
                    | TFriendMessageRecallevent): void;
            } & {
                notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
                notice.friend_add(event: TFriendAddEvent): void;
                notice.friend_recall(event: TFriendMessageRecallevent): void;
            } & {
                notice(event:
                    | TGroupFileUploadEvent
                    | TGroupAdminChangeEvent
                    | TGroupMemberDecreaseEvent
                    | TGroupMemberIncreaseEvent
                    | TGroupMuteEvent
                    | TGroupMessageRecallEvent): void;
                notice.group_admin(event: TGroupAdminChangeEvent): void;
                notice.group_ban(event: TGroupMuteEvent): void;
                notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
                notice.group_increase(event: TGroupMemberIncreaseEvent): void;
                notice.group_recall(event: TGroupMessageRecallEvent): void;
                notice.group_upload(event: TGroupFileUploadEvent): void;
            } & {
                request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
            } & {
                request(event: TFriendAddInviteEvent): void;
                request.friend(event: TFriendAddInviteEvent): void;
            } & {
                request(event: TMemberAddOrInviteEvent): void;
                request.group.add(event: TBaseEvent & {
                    comment: string;
                    flag: string;
                    post_type: "request";
                    request_type: "group" | "friend";
                    user_id: number;
                } & {
                    group_id: number;
                    request_type: "group";
                    sub_type: "add" | "invite";
                    approve(isApprove?: boolean, reason?: string): void;
                } & {
                    sub_type: "add";
                }): void;
                request.group.invite(event: TBaseEvent & {
                    comment: string;
                    flag: string;
                    post_type: "request";
                    request_type: "group" | "friend";
                    user_id: number;
                } & {
                    group_id: number;
                    request_type: "group";
                    sub_type: "add" | "invite";
                    approve(isApprove?: boolean, reason?: string): void;
                } & {
                    sub_type: "invite";
                }): void;
            } & TBaseClientEventMap>[Extract<T,
                | "message.private"
                | "message.private.friend"
                | "message.private.group"
                | "message.private.other"
                | "message.group"
                | "message.group.normal"
                | "message.group.anonymous"
                | "message.group.notice"
                | "notice"
                | "notice.friend_add"
                | "notice.friend_recall"
                | "notice.group_upload"
                | "notice.group_admin"
                | "notice.group_decrease"
                | "notice.group_increase"
                | "notice.group_ban"
                | "notice.group_recall"
                | "request"
                | "request.friend"
                | "request.group.add"
                | "request.group.invite"
                | "data"
                | "message"
                | "error"
                | "open"
                | "close">]

          Returns void

    • Optionalcontext: any

    Returns this

removeAllListeners

  • removeAllListeners(event?): this

  • Remove all listeners, or those of the specified event.

    Parameters

    • Optionalevent:
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close"

    Returns this

removeListener

  • removeListener<T>(event, fn?, context?, once?): this

  • Remove the listeners of a given event.

    Type Parameters

    • T extends
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close"

    Parameters

    • event: T
    • Optionalfn: ((...args: ArgumentMap<{
          message(event: TPrivateMessageEvent | TGroupMemberSender): void;
      } & {
          message.private(event: TPrivateMessageEvent): void;
          message.private.friend(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "friend";
          }): void;
          message.private.group(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "group";
          }): void;
          message.private.other(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              message_type: "private";
              sender: TStrangerInfo;
              sub_type: "group" | "friend" | "other";
          } & {
              sub_type: "other";
          }): void;
      } & {
          message.group(event: TGroupMessageEvent): void;
          message.group.anonymous(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "anonymous";
          }): void;
          message.group.normal(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "normal";
          }): void;
          message.group.notice(event: TBaseEvent & {
              font: number;
              message: TElements;
              message_id: number;
              message_type: "private" | "group";
              post_type: "message";
              raw_message: string;
              sub_type: string;
              user_id: number;
              forwardMessage(target_id: number): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
              replyViaEmoji(emoji_id: number): void;
          } & {
              anonymous: null | TAnonymous;
              group_id: number;
              message_type: "group";
              sender: TGroupMemberSender;
              sub_type: "notice" | "normal" | "anonymous";
              kick(): void;
              mute(ban_duration?: number): void;
              recall(): void;
              reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
          } & {
              sub_type: "notice";
          }): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent
              | TFriendAddEvent
              | TFriendMessageRecallevent): void;
      } & {
          notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
          notice.friend_add(event: TFriendAddEvent): void;
          notice.friend_recall(event: TFriendMessageRecallevent): void;
      } & {
          notice(event:
              | TGroupFileUploadEvent
              | TGroupAdminChangeEvent
              | TGroupMemberDecreaseEvent
              | TGroupMemberIncreaseEvent
              | TGroupMuteEvent
              | TGroupMessageRecallEvent): void;
          notice.group_admin(event: TGroupAdminChangeEvent): void;
          notice.group_ban(event: TGroupMuteEvent): void;
          notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
          notice.group_increase(event: TGroupMemberIncreaseEvent): void;
          notice.group_recall(event: TGroupMessageRecallEvent): void;
          notice.group_upload(event: TGroupFileUploadEvent): void;
      } & {
          request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
      } & {
          request(event: TFriendAddInviteEvent): void;
          request.friend(event: TFriendAddInviteEvent): void;
      } & {
          request(event: TMemberAddOrInviteEvent): void;
          request.group.add(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "add";
          }): void;
          request.group.invite(event: TBaseEvent & {
              comment: string;
              flag: string;
              post_type: "request";
              request_type: "group" | "friend";
              user_id: number;
          } & {
              group_id: number;
              request_type: "group";
              sub_type: "add" | "invite";
              approve(isApprove?: boolean, reason?: string): void;
          } & {
              sub_type: "invite";
          }): void;
      } & TBaseClientEventMap>[Extract<T,
          | "message.private"
          | "message.private.friend"
          | "message.private.group"
          | "message.private.other"
          | "message.group"
          | "message.group.normal"
          | "message.group.anonymous"
          | "message.group.notice"
          | "notice"
          | "notice.friend_add"
          | "notice.friend_recall"
          | "notice.group_upload"
          | "notice.group_admin"
          | "notice.group_decrease"
          | "notice.group_increase"
          | "notice.group_ban"
          | "notice.group_recall"
          | "request"
          | "request.friend"
          | "request.group.add"
          | "request.group.invite"
          | "data"
          | "message"
          | "error"
          | "open"
          | "close">]) => void)
        • (...args): void

        • Parameters

          • Rest...args: ArgumentMap<{
                message(event: TPrivateMessageEvent | TGroupMemberSender): void;
            } & {
                message.private(event: TPrivateMessageEvent): void;
                message.private.friend(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "friend";
                }): void;
                message.private.group(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "group";
                }): void;
                message.private.other(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    message_type: "private";
                    sender: TStrangerInfo;
                    sub_type: "group" | "friend" | "other";
                } & {
                    sub_type: "other";
                }): void;
            } & {
                message.group(event: TGroupMessageEvent): void;
                message.group.anonymous(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "anonymous";
                }): void;
                message.group.normal(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "normal";
                }): void;
                message.group.notice(event: TBaseEvent & {
                    font: number;
                    message: TElements;
                    message_id: number;
                    message_type: "private" | "group";
                    post_type: "message";
                    raw_message: string;
                    sub_type: string;
                    user_id: number;
                    forwardMessage(target_id: number): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                    replyViaEmoji(emoji_id: number): void;
                } & {
                    anonymous: null | TAnonymous;
                    group_id: number;
                    message_type: "group";
                    sender: TGroupMemberSender;
                    sub_type: "notice" | "normal" | "anonymous";
                    kick(): void;
                    mute(ban_duration?: number): void;
                    recall(): void;
                    reply(message: TElements, at_sender?: boolean, auto_escape?: boolean): void;
                } & {
                    sub_type: "notice";
                }): void;
            } & {
                notice(event:
                    | TGroupFileUploadEvent
                    | TGroupAdminChangeEvent
                    | TGroupMemberDecreaseEvent
                    | TGroupMemberIncreaseEvent
                    | TGroupMuteEvent
                    | TGroupMessageRecallEvent
                    | TFriendAddEvent
                    | TFriendMessageRecallevent): void;
            } & {
                notice(event: TFriendAddEvent | TFriendMessageRecallevent): void;
                notice.friend_add(event: TFriendAddEvent): void;
                notice.friend_recall(event: TFriendMessageRecallevent): void;
            } & {
                notice(event:
                    | TGroupFileUploadEvent
                    | TGroupAdminChangeEvent
                    | TGroupMemberDecreaseEvent
                    | TGroupMemberIncreaseEvent
                    | TGroupMuteEvent
                    | TGroupMessageRecallEvent): void;
                notice.group_admin(event: TGroupAdminChangeEvent): void;
                notice.group_ban(event: TGroupMuteEvent): void;
                notice.group_decrease(event: TGroupMemberDecreaseEvent): void;
                notice.group_increase(event: TGroupMemberIncreaseEvent): void;
                notice.group_recall(event: TGroupMessageRecallEvent): void;
                notice.group_upload(event: TGroupFileUploadEvent): void;
            } & {
                request(event: TFriendAddInviteEvent | [event: TMemberAddOrInviteEvent]): void;
            } & {
                request(event: TFriendAddInviteEvent): void;
                request.friend(event: TFriendAddInviteEvent): void;
            } & {
                request(event: TMemberAddOrInviteEvent): void;
                request.group.add(event: TBaseEvent & {
                    comment: string;
                    flag: string;
                    post_type: "request";
                    request_type: "group" | "friend";
                    user_id: number;
                } & {
                    group_id: number;
                    request_type: "group";
                    sub_type: "add" | "invite";
                    approve(isApprove?: boolean, reason?: string): void;
                } & {
                    sub_type: "add";
                }): void;
                request.group.invite(event: TBaseEvent & {
                    comment: string;
                    flag: string;
                    post_type: "request";
                    request_type: "group" | "friend";
                    user_id: number;
                } & {
                    group_id: number;
                    request_type: "group";
                    sub_type: "add" | "invite";
                    approve(isApprove?: boolean, reason?: string): void;
                } & {
                    sub_type: "invite";
                }): void;
            } & TBaseClientEventMap>[Extract<T,
                | "message.private"
                | "message.private.friend"
                | "message.private.group"
                | "message.private.other"
                | "message.group"
                | "message.group.normal"
                | "message.group.anonymous"
                | "message.group.notice"
                | "notice"
                | "notice.friend_add"
                | "notice.friend_recall"
                | "notice.group_upload"
                | "notice.group_admin"
                | "notice.group_decrease"
                | "notice.group_increase"
                | "notice.group_ban"
                | "notice.group_recall"
                | "request"
                | "request.friend"
                | "request.group.add"
                | "request.group.invite"
                | "data"
                | "message"
                | "error"
                | "open"
                | "close">]

          Returns void

    • Optionalcontext: any
    • Optionalonce: boolean

    Returns this

Settings

Member Visibility

On This Page

Constructors
Properties
Methods