mirai-ts/dist/index.d.ts

Mirai TypeScript SDK

import * as consola from 'consola';
import { AxiosResponse, AxiosStatic } from 'axios';
import WebSocket from 'ws';
import events from 'node:events';

/**
 * 群设置与成员信息设置
 * @packageDocumentation
 */
/**
 * 群设置
 */
interface GroupConfig$1 {
    /**
     * 群名
     */
    name?: string;
    /**
     * 群公告
     */
    announcement?: string;
    /**
     * 是否开启坦白说
     */
    confessTalk?: boolean;
    /**
     * 是否允许群员邀请
     */
    allowMemberInvite?: boolean;
    /**
     * 是否开启自动审批入群
     */
    autoApprove?: boolean;
    /**
     * 是否允许匿名聊天
     */
    anonymousChat?: boolean;
}
/**
 * 群员信息
 */
interface MemberInfo$1 {
    /**
     * 群名片
     */
    name?: string;
    /**
     * 群头衔
     */
    specialTitle?: string;
}

declare namespace config {
  export {
    GroupConfig$1 as GroupConfig,
    MemberInfo$1 as MemberInfo,
  };
}

interface BaseRequestParams {
    sessionKey: string;
}
type RequestParams<T> = T & BaseRequestParams;
/**
 * 基础的发送消息格式
 */
type SendMessage$1 = RequestParams<{
    target: number;
    messageChain: MessageType.MessageChain;
}>;
/**
 * 发送好友消息的请求格式
 */
interface SendFriendMessage extends SendMessage$1 {
    quote?: number;
}
interface SendGroupMessage extends SendMessage$1 {
    quote?: number;
}
type SendTempMessage = RequestParams<{
    messageChain: MessageType.MessageChain;
    qq: number;
    group: number;
    quote?: number;
}>;
type SendImageMessage = RequestParams<{
    urls: string[];
    target?: number;
    qq?: number;
    group?: number;
}>;
type Recall = RequestParams<{
    /**
     * 好友id或群id
     */
    target: number;
    messageId: number;
}>;
type Unmute = RequestParams<{
    target: number;
    memberId: number;
}>;
interface Mute extends Unmute {
    time: number;
}
type MuteAll = RequestParams<{
    target: number;
}>;
type UnmuteAll = MuteAll;
type Kick = RequestParams<{
    target: number;
    memberId: number;
    msg: string;
}>;
type Quit = MuteAll;
type GroupConfig = RequestParams<{
    target: number;
    config?: GroupConfig$1;
}>;
type MemberInfo = RequestParams<{
    target: number;
    memberId: number;
    info?: MemberInfo$1;
}>;
type SetEssence = RequestParams<{
    target: number;
}>;
type SendNudge = RequestParams<{
    target: number;
    subject: number;
    kind: 'Friend' | 'Group' | 'Stranger';
}>;
type GroupFileRename = RequestParams<{
    target: number;
    id: string;
    rename: string;
}>;
type GroupMkdir = RequestParams<{
    group: number;
    dir: string;
}>;
type GroupFileMove = RequestParams<{
    target: number;
    id: string;
    movePath: string;
}>;

type params_BaseRequestParams = BaseRequestParams;
type params_GroupConfig = GroupConfig;
type params_GroupFileMove = GroupFileMove;
type params_GroupFileRename = GroupFileRename;
type params_GroupMkdir = GroupMkdir;
type params_Kick = Kick;
type params_MemberInfo = MemberInfo;
type params_Mute = Mute;
type params_MuteAll = MuteAll;
type params_Quit = Quit;
type params_Recall = Recall;
type params_RequestParams<T> = RequestParams<T>;
type params_SendFriendMessage = SendFriendMessage;
type params_SendGroupMessage = SendGroupMessage;
type params_SendImageMessage = SendImageMessage;
type params_SendNudge = SendNudge;
type params_SendTempMessage = SendTempMessage;
type params_SetEssence = SetEssence;
type params_Unmute = Unmute;
type params_UnmuteAll = UnmuteAll;
declare namespace params {
  export {
    params_BaseRequestParams as BaseRequestParams,
    params_GroupConfig as GroupConfig,
    params_GroupFileMove as GroupFileMove,
    params_GroupFileRename as GroupFileRename,
    params_GroupMkdir as GroupMkdir,
    params_Kick as Kick,
    params_MemberInfo as MemberInfo,
    params_Mute as Mute,
    params_MuteAll as MuteAll,
    params_Quit as Quit,
    params_Recall as Recall,
    params_RequestParams as RequestParams,
    params_SendFriendMessage as SendFriendMessage,
    params_SendGroupMessage as SendGroupMessage,
    params_SendImageMessage as SendImageMessage,
    SendMessage$1 as SendMessage,
    params_SendNudge as SendNudge,
    params_SendTempMessage as SendTempMessage,
    params_SetEssence as SetEssence,
    params_Unmute as Unmute,
    params_UnmuteAll as UnmuteAll,
  };
}

/**
 * 联系实体类型，参考 [mirai-core 命名](https://github.com/mamoe/mirai/tree/master/mirai-core/src/commonMain/kotlin/net.mamoe.mirai/contact)
 * @packageDocumentation
 */
type Permission = 'OWNER' | 'ADMINISTRATOR' | 'MEMBER';
/**
 * 群的信息
 */
interface Group {
    /**
     * 群号
     */
    id: number;
    /**
     * 群的群名称
     */
    name: string;
    /**
     * 群中，Bot的群限权
     */
    permission: Permission;
}
/**
 * 基础用户信息
 */
interface BaseUser {
    /**
     * QQ 号
     */
    id: number;
}
/**
 * 好友信息类型
 */
interface Friend extends BaseUser {
    /**
     * 用户昵称
     */
    nickname: string;
    /**
     * 用户备注
     */
    remark: string;
}
/**
 * 群成员信息类型
 */
interface Member extends BaseUser {
    /**
     * 群名片
     */
    memberName: string;
    /**
     * 群权限 OWNER、ADMINISTRATOR 或 MEMBER
     */
    permission: Permission;
    /**
     * 群头衔
     */
    specialTitle: string;
    /**
     * 入群时间戳
     */
    joinTimestamp: number;
    /**
     * 上一次发言时间戳
     */
    lastSpeakTimestamp: number;
    /**
     * 剩余禁言时间
     */
    muteTimeRemaining: number;
    /**
     * 所在的群
     */
    group: Group;
}
type User = Friend | Member;

type contact_Friend = Friend;
type contact_Group = Group;
type contact_Member = Member;
type contact_Permission = Permission;
type contact_User = User;
declare namespace contact {
  export {
    contact_Friend as Friend,
    contact_Group as Group,
    contact_Member as Member,
    contact_Permission as Permission,
    contact_User as User,
  };
}

/**
 * 消息类型，与 [Mirai-api-http 消息类型一览](https://github.com/project-mirai/mirai-api-http/blob/master/docs/MessageType.md) 保持一致
 * @packageDocumentation
 */

declare namespace MessageType {
    interface BaseSingleMessage {
        type: string;
    }
    /**
     * 源消息类型
     */
    export interface Source extends BaseSingleMessage {
        type: 'Source';
        /**
         * 消息的识别号，用于引用回复（Source 类型永远为 chain 的第一个元素）
         */
        id: number;
        /**
         * 时间戳
         */
        time: number;
    }
    /**
     * 引用消息类型
     */
    export interface Quote extends BaseSingleMessage {
        type: 'Quote';
        /**
         * 被引用回复的原消息的messageId
         */
        id: number;
        /**
         * 被引用回复的原消息所接收的群号，当为好友消息时为0
         */
        groupId?: number;
        /**
         * 被引用回复的原消息的发送者的QQ号
         */
        senderId?: number;
        /**
         * 被引用回复的原消息的接收者者的QQ号（或群号）
         */
        targetId?: number;
        /**
         * 被引用回复的原消息的消息链对象
         */
        origin?: MessageChain;
    }
    /**
     * 艾特某人消息
     */
    export interface At extends BaseSingleMessage {
        type: 'At';
        /**
         * 群员QQ号
         */
        target: number;
        /**
         * At 时显示的文字，发送消息时无效，自动使用群名片
         */
        display: string;
    }
    /**
     * 艾特全体成员消息
     */
    export interface AtAll extends BaseSingleMessage {
        type: 'AtAll';
    }
    /**
     * 原生表情消息
     */
    export interface Face extends BaseSingleMessage {
        type: 'Face';
        /**
         * QQ表情编号，可选，优先高于name
         */
        faceId: number;
        /**
         * QQ表情拼音，可选
         */
        name: string;
    }
    /**
     * 文本消息
     */
    export interface Plain extends BaseSingleMessage {
        type: 'Plain';
        /**
         * 文字消息
         */
        text: string;
    }
    /**
     * 图片消息
     */
    export interface Image extends BaseSingleMessage {
        type: 'Image';
        /**
         * 图片的 imageId，群图片与好友图片格式不同。不为空时将忽略 url 属性
         */
        imageId: string | null;
        /**
         * 图片的 URL，发送时可作网络图片的链接；接收时为腾讯图片服务器的链接，可用于图片下载
         */
        url: string | null;
        /**
         * 图片的路径，发送本地图片，相对路径于 `data/net.mamoe.mirai-api-http/images`
         */
        path: string | null;
        /**
         * 图片的 Base64 编码
         */
        base64: string | null;
    }
    /**
     * 闪照消息
     */
    export interface FlashImage extends BaseSingleMessage {
        type: 'FlashImage';
        /**
         * 图片的imageId，群图片与好友图片格式不同。不为空时将忽略url属性
         */
        imageId: string | null;
        /**
         * 图片的URL，发送时可作网络图片的链接；接收时为腾讯图片服务器的链接，可用于图片下载
         */
        url: string | null;
        /**
         * 图片的路径，发送本地图片，相对路径于 `data/net.mamoe.mirai-api-http/images`
         */
        path: string | null;
    }
    /**
     * 语音消息
     */
    export interface Voice extends BaseSingleMessage {
        type: 'Voice';
        /**
         * 语音的 voiceId，不为空时将忽略 url 属性
         */
        voiceId: string | null;
        /**
         * 语音的 URL，发送时可作网络语音的链接；接收时为腾讯语音服务器的链接，可用于语音下载
         */
        url: string | null;
        /**
         * 语音的路径，发送本地语音，路径相对于 JVM 工作路径（默认是当前路径，可通过 -Duser.dir=...指定），也可传入绝对路径。
         */
        path: string | null;
        /**
         * 语音的 Base64 编码
         */
        base64: string | null;
        /**
         * 返回的语音长度, 发送消息时可以不传
         */
        length?: number;
    }
    /**
     * 富文本消息（譬如合并转发）
     */
    export interface Xml extends BaseSingleMessage {
        type: 'Xml';
        /**
         * XML文本
         */
        xml: string;
    }
    export interface Json extends BaseSingleMessage {
        type: 'Json';
        /**
         * Json文本
         */
        json: string;
    }
    /**
     * 小程序消息
     */
    export interface App extends BaseSingleMessage {
        type: 'App';
        /**
         * 内容
         */
        content: string;
    }
    /**
     * "Poke": 戳一戳
     * "ShowLove": 比心
     * "Like": 点赞
     * "Heartbroken": 心碎
     * "SixSixSix": 666
     * "FangDaZhao": 放大招
     */
    export enum PokeName {
        Poke = "Poke",
        ShowLove = "ShowLove",
        Like = "Like",
        Heartbroken = "Heartbroken",
        SixSixSix = "SixSixSix",
        FangDaZhao = "FangDaZhao"
    }
    /**
     * 戳一戳消息
     */
    export interface Poke extends BaseSingleMessage {
        type: 'Poke';
        /**
         * 戳一戳的类型
         */
        name: PokeName;
    }
    export interface Dice extends BaseSingleMessage {
        type: 'Dice';
        /**
         * 点数
         */
        value: number;
    }
    export type ForwardNode = {
        /**
         * 发送者 id
         */
        senderId: number;
        /**
         * 时间戳, 单位 秒
         */
        time: number;
        /**
         * 发送者姓名
         */
        senderName: string;
        messageChain: MessageChain;
    } | {
        /**
         * 可以只使用消息messageId，从缓存中读取一条消息作为节点
         */
        messageId: number;
    };
    /**
     * 转发
     */
    export interface Forward extends BaseSingleMessage {
        type: 'Forward';
        /**
         * 标题，XX的聊天记录
         */
        title: string;
        /**
         * 简介，[聊天记录]
         */
        brief: string;
        /**
         * 源
         */
        source: string;
        /**
         * 摘要，查看 3 条转发消息
         */
        summary: string;
        /**
         * 转发内容
         */
        nodeList: ForwardNode[];
    }
    export interface File {
        type: 'File';
        /**
         * 文件识别 id
         */
        id: string;
        /**
         * 文件名字
         */
        name: string;
        /**
         * 文件大小
         */
        size: number;
    }
    export type MusicShareKind = 'NeteaseCloudMusic' | 'QQMusic' | 'MiguMusic';
    /**
     * 音乐分享
     */
    export interface MusicShare {
        type: 'MusicShare';
        /**
         * 音乐应用类型
         */
        kind: 'NeteaseCloudMusic' | 'QQMusic' | 'MiguMusic';
        /**
         * 消息卡片标题
         */
        title: string;
        /**
         * 消息卡片内容
         */
        summary: string;
        /**
         * 点击卡片跳转网页 URL
         */
        jumpUrl: string;
        /**
         * 消息卡片图片 URL
         */
        pictureUrl: string;
        /**
         * 音乐文件 URL
         */
        musicUrl: string;
        /**
         * 简介，在消息列表显示，默认为 `[分享]$title`
         */
        brief?: string;
    }
    export interface MiraiCode {
        type: 'MiraiCode';
        /**
         * MiraiCode
         * @example hello[mirai:at:1234567]
         */
        code: string;
    }
    export interface SingleMessageMap {
        Source: Source;
        Quote: Quote;
        At: At;
        AtAll: AtAll;
        Face: Face;
        Plain: Plain;
        Image: Image;
        FlashImage: FlashImage;
        Voice: Voice;
        Xml: Xml;
        Json: Json;
        App: App;
        Poke: Poke;
        Dice: Dice;
        Forward: Forward;
        MusicShare: MusicShare;
        File: File;
        MiraiCode: MiraiCode;
    }
    export type SingleMessageType = keyof SingleMessageMap;
    /**
     * FriendMessage | GroupMessage | TempMessage 下的 MessageChain 中的单条消息类型
     * 单条消息 此处命名与 mamoe/mirai-core 保持一致
     */
    export type SingleMessage = SingleMessageMap[SingleMessageType];
    /**
     * 消息链
     */
    export type MessageChain = Array<SingleMessage>;
    interface BaseChatMessage extends BaseSingleMessage {
        type: 'GroupMessage' | 'TempMessage' | 'FriendMessage';
        messageChain: MessageChain & {
            0: Source;
        };
        sender: User;
        /**
         * 快捷回复函数
         */
        reply: (msgChain: string | MessageChain, quote?: boolean) => Promise<SendMessage$1>;
        /**
         * 消息文本
         */
        plain: string;
        /**
         * 是否为某群 groupId 发送
         * msg.group(114514)
         */
        group: (...groupIds: number[]) => boolean;
        /**
         * 是否为某个好友 qq 发送
         * msg.friend(114514)
         */
        friend: (...qqs: number[]) => boolean;
        /**
         * 获取消息链中第一次出现的消息类型
         * 例如：msg.get('Quote')
         */
        get: <T extends SingleMessage['type']>(type: T) => SingleMessageMap[T] | null;
    }
    export interface FriendMessage extends BaseChatMessage {
        type: 'FriendMessage';
        sender: Friend;
    }
    export interface GroupMessage extends BaseChatMessage {
        type: 'GroupMessage';
        sender: Member;
        /**
         * 判断是否艾特某人（留空则判断是否艾特自己）
         */
        isAt: (qq?: number) => boolean;
    }
    export interface TempMessage extends BaseChatMessage {
        type: 'TempMessage';
        sender: Member;
    }
    /**
     * 包括 FriendMessage GroupMessage TempMessage
     */
    export type ChatMessage = GroupMessage | TempMessage | FriendMessage;
    /**
     * 聊天消息类型
     */
    export type ChatMessageType = ChatMessage['type'];
    export interface ChatMessageMap {
        message: ChatMessage;
        GroupMessage: GroupMessage;
        FriendMessage: FriendMessage;
        TempMessage: TempMessage;
    }
    export {};
}

/**
 * 与 mirai-api-http [setting.yml](https://github.com/project-mirai/mirai-api-http#settingyml模板) 的配置保持一致
 * @packageDocumentation
 */
type Adapter = 'http' | 'ws' | 'reverse-ws' | 'webhook';
/**
 * 提供基于轮询的 http 接口
 */
interface HttpAdapter {
    /**
     * http server 监听的本地地址
     * 一般为 localhost 即可, 如果多网卡等情况，自定设置
     * @default "localhost"
     */
    host: string;
    /**
     * http server 监听的端口
     * 与 websocket server 可以重复, 由于协议与路径不同, 不会产生冲突
     * @default 4859
     */
    port: number;
    /**
     * 配置跨域, * 默认允许来自所有域名
     */
    cors?: string[];
}
/**
 * 提供基于 websocket server 的接口
 */
interface WebsocketAdapter {
    /**
     * websocket server 监听的本地地址
     * 一般为 localhost 即可, 如果多网卡等情况，自定设置
     * @default "localhost"
     */
    host: string;
    /**
     * websocket server 监听的端口
     * 与 http server 可以重复, 由于协议与路径不同, 不会产生冲突
     * @default 4859
     */
    port: number;
    /**
     * websocket 用于消息同步的字段为 syncId, 一般值为请求时的原值，用于同步一次请求与响应
     * 对于由 websocket server 主动发出的通知, 固定使用一个 syncId, 默认为 ”-1“
     */
    reservedSyncId?: string;
}
/**
 * 提供基于 websocket client 的接口
 */
interface ReverseWebsocketAdapter {
    /**
     * 远端 server host
     */
    destinations: {
        host: string;
        port: number;
        /**
         * 请求路径
         */
        path: string;
        /**
         * 协议
         */
        protocol: ('ws' | 'wss')[];
        /**
         * 请求方式，通常为 GET
         */
        method: string;
        /**
         * 额外参数，该连接有效
         */
        extraParameters?: Record<string, string>;
        /**
         * 额外请求头，该连接有效
         */
        extraHeaders?: Record<string, string>;
    };
    /**
     * 额外请求参数，全 client 有效; 会被具体 destination 中的覆盖
     */
    extraParameters?: Record<string, string>;
    /**
     * 额外请求头，全 client 有效; 会被具体 destination 中的覆盖
     */
    extraHeaders?: Record<string, string>;
    /**
     * websocket 用于消息同步的字段为 syncId, 一般值为请求时的原值，用于同步一次请求与响应
     * 对于由 websocket client 主动发出的通知, 固定使用一个 syncId, 默认为 ”-1“
     */
    reservedSyncId?: string;
}
/**
 * 提供 http 回调形式的接口, 可单纯做上报使用
 */
interface WebhookAdapter {
    /**
     * 回调(上报)地址
     */
    destinations: string[];
    /**
     * 额外自定义请求头
     */
    extraHeaders: {
        Authorization: string;
        [key: string]: string;
    };
}
/**
 * setting.yml
 */
interface MiraiApiHttpSetting {
    /**
     * 启用的 adapter, 内置有 http, ws, reverse-ws, webhook
     */
    adapters: Adapter[];
    /**
     * 是否开启认证流程, 若为 true 则建立连接时需要验证 verifyKey
     * @default true
     */
    enableVerify: boolean;
    /**
     * 默认由 mirai-api-http 随机生成，建议手动指定。
     * @default "el-psy-congroo"
     */
    verifyKey: string;
    /**
     * 开启一些调试信息
     * @default true
     */
    debug?: boolean;
    /**
     * 是否开启单 session 模式, 若为 true，则自动创建 session 绑定 console 中登录的 bot
     * 开启后，接口中任何 sessionKey 不需要传递参数
     * 若 console 中有多个 bot 登录，则行为未定义
     * 确保 console 中只有一个 bot 登陆时启用
     * @default false
     */
    singleMode: boolean;
    /**
     * 历史消息的缓存大小
     * 同时，也是 http adapter 的消息队列容量
     * @default 4096
     */
    cacheSize: number;
    /**
     * adapter 的单独配置，键名与 adapters 项配置相同
     */
    adapterSettings: {
        'http': HttpAdapter;
        'ws': WebsocketAdapter;
        'reverse-ws'?: ReverseWebsocketAdapter;
        'webhook'?: WebhookAdapter;
    };
}

declare enum Sex {
    UNKNOWN = "UNKNOWN",
    MALE = "MALE",
    FEMALE = "FEMALE"
}
interface UserProfile {
    nickname: string;
    email: string;
    age: number;
    level: number;
    /**
     * mirai ?
     */
    sign: string;
    sex: Sex;
}

/**
 * API 请求格式
 * @packageDocumentation
 */

declare namespace index {
  export {
    params as Params,
    response as Response,
  };
}

/**
 * mirai-ts 自定义配置项，与 mirai-api-http setting 相区别
 */
interface MiraiOptions {
    http?: {
        address?: string;
    };
    ws?: {
        address?: string;
        /**
         * 心跳间隔
         * @default 60000
         */
        heartbeatInterval?: number;
    };
}

/**
 * 指令系统
 * @packageDocumentation
 * https://github.com/project-mirai/mirai-api-http/blob/master/mirai-api-http/src/main/kotlin/net/mamoe/mirai/api/http/adapter/internal/consts/paths.kt
 */

interface CommandInfo {
    name: string;
    sender: number;
    group: number;
    args: string[];
}
/**
 * [插件相关、Console相关 | mirai-api-http](https://github.com/project-mirai/mirai-api-http#%E6%8F%92%E4%BB%B6%E7%9B%B8%E5%85%B3console%E7%9B%B8%E5%85%B3)
 */
declare class Command {
    api: MiraiApiHttp;
    constructor(api: MiraiApiHttp);
    /**
     * 监听指令
     * - 当指令通过好友消息发送时，sender 为好友 QQ 号，group 为 0
     * - 当指令通过群组消息发送时，sender 为发送人 QQ 号，group 为群号
     * - 当指令通过其他方式发送时，如控制台、HTTP 接口等，sender 和 group 均为 0
     */
    listen(): Promise<CommandInfo>;
    /**
     * 注册指令
     * @param name 指令名
     * @param alias 指令别名
     * @param description 指令描述
     * @param usage 使用说明，会在指令执行错误时显示
     */
    register(name: string, alias: string[], description: string, usage?: string): Promise<RequestParams<{
        name: string;
        alias: string[];
        description: string;
        usage?: string;
    }>>;
    /**
     * 发送指令
     * @param command 命令与参数
     */
    execute(command: string[]): Promise<BaseResponse>;
}

/**
 * 文件操作
 * @packageDocumentation
 */

type FileInfoResponse = AxiosResponse<ResponseType<FileInfo>>;
interface BaseFileOptions {
    /**
     * 文件 ID
     */
    id: string;
    /**
     * 文件夹路径, 文件夹允许重名, 不保证准确, 准确定位使用 id
     */
    path?: string;
    /**
     * 群号或好友QQ号
     */
    target?: number;
    /**
     * 群号
     */
    group?: number;
    /**
     * 好友QQ号
     */
    qq?: number;
}
/**
 * 群文件信息
 */
interface FileInfo {
    /**
     * 文件名字
     */
    name: string;
    /**
     * 文件 ID
     */
    id: string;
    /**
     * 文件对象, 递归类型. null 为存在根目录
     */
    parent: FileInfo;
    /**
     * 群信息或好友信息
     */
    contact: User;
    /**
     * 是否文件
     */
    isFile: boolean;
    /**
     * 是否文件夹
     */
    isDirectory: boolean;
    /**
     * 文件下载信息
     */
    downloadInfo: {
        /**
         * 下载次数
         */
        downloadTimes: number;
        /**
         * 上传者QQ
         */
        uploaderId: number;
        /**
         * 上传时间
         */
        uploadTime: number;
        /**
         * 最后修改时间
         */
        lastModifyTime: number;
        /**
         * 文件 sha1 值
         */
        sha1: string;
        /**
         * 文件 md5 值
         */
        md5: string;
        /**
         * 文件下载 url
         */
        url: string;
    };
}
interface FileListOptions extends BaseFileOptions {
    /**
     * 是否携带下载信息，额外请求，无必要不要携带
     */
    withDownloadInfo?: number;
    /**
     * 分页偏移
     */
    offset?: number;
    /**
     * 分页大小
     */
    size?: number;
}
type FileListResponse = AxiosResponse<ResponseType<FileInfo[]>>;
interface FileInfoOptions extends BaseFileOptions {
    /**
     * 是否携带下载信息，额外请求，无必要不要携带
     */
    withDownloadInfo?: number;
}
type FileInfoParams = RequestParams<FileInfoOptions>;
interface FileMkdirOptions extends BaseFileOptions {
    /**
     * 新建文件夹名
     */
    directoryName: string;
}
type FileMkdirParams = RequestParams<FileMkdirOptions>;
type FileDeleteOptions = BaseFileOptions;
type FileDeleteParams = RequestParams<BaseFileOptions>;
interface FileRenameOptions extends BaseFileOptions {
    /**
     * 新文件名
     */
    renameTo?: string;
}
type FileRenameParams = RequestParams<FileRenameOptions>;
interface FileMoveOptions extends BaseFileOptions {
    /**
     * 移动目标文件夹 id
     */
    moveTo?: string;
    /**
     * 移动目标文件路径, 文件夹允许重名, 不保证准确, 准确定位使用 moveTo
     */
    moveToPath?: string;
}
type FileMoveParams = RequestParams<FileMoveOptions>;
/**
 * [文件操作 | mirai-api-http](https://github.com/project-mirai/mirai-api-http/blob/master/docs/api/API.md#%E6%96%87%E4%BB%B6%E6%93%8D%E4%BD%9C)
 * [文件操作 Http Adapter](https://github.com/project-mirai/mirai-api-http/blob/master/docs/adapter/HttpAdapter.md#%E6%96%87%E4%BB%B6%E6%93%8D%E4%BD%9C)
 */
declare class File {
    api: MiraiApiHttp;
    constructor(api: MiraiApiHttp);
    /**
     * 获取群文件列表
     * @param target 指定群的群号
     * @param dir 指定查询目录，不填为根目录
     */
    /**
     * 目前仅支持群文件的操作, 所有好友文件的字段为保留字段
     * @param options
     */
    list(options: FileListOptions): Promise<ResponseType<FileInfo[]>>;
    /**
     * 获取文件信息
     * @param options
     */
    info(options: FileInfoOptions): Promise<ResponseType<FileInfo>>;
    /**
     * 创建文件夹
     * @param options
     */
    mkdir(options: FileMkdirOptions): Promise<ResponseType<FileInfo>>;
    /**
     * 删除文件
     */
    delete(options: FileDeleteOptions): Promise<BaseResponse>;
    /**
     * 移动文件
     * @param options
     */
    move(options: FileMoveOptions): Promise<BaseResponse>;
    /**
     * 重命名文件
     */
    rename(options: FileRenameOptions): Promise<BaseResponse>;
}

/**
 * 转化为标准的 MessageChain
 */
declare function toMessageChain(messageChain: string | MessageType.SingleMessage | MessageType.MessageChain): MessageType.MessageChain;

/**
 * [状态码 | mirai-api-http](https://github.com/project-mirai/mirai-api-http/blob/master/docs/API.md#%E7%8A%B6%E6%80%81%E7%A0%81)
 */
declare enum StatusCode {
    NORMAL = 0,
    ERROR_VERIFY_KEY = 1,
    BOT_NOT_EXIST = 2,
    SESSION_INVALID = 3,
    SESSION_INACTIVATED = 4,
    TARGET_NOT_EXIST = 5,
    FILE_NOT_EXIST = 6,
    NO_OPERATION_AUTH = 10,
    BOT_MUTED = 20,
    MESSAGE_TOO_LONG = 30,
    WRONG_VISIT = 400,
    ERROR_SERVER = 500
}
declare const StatusCodeMap: Map<StatusCode, string>;
/**
 * 状态码及其对应消息
 * @param code Mirai 状态码
 */
declare function getMessageFromStatusCode(code: StatusCode): string;

interface WsCallbackMap {
    message: (msg: MessageType.ChatMessage) => any;
    event: (event: Event) => any;
    all: (data: Event | MessageType.ChatMessage) => any;
}
type RecallParams = Pick<Recall, 'target' | 'messageId'>;
declare class MiraiApiHttp {
    mirai: Mirai;
    axios: AxiosStatic;
    setting: MiraiApiHttpSetting;
    sessionKey: string;
    /**
     * http adapter
     */
    http: {
        address: string;
    };
    /**
     * WebSocket SessionKey
     */
    ws: {
        sessionKey: string;
        address: string;
        client?: WebSocket;
    };
    qq: number;
    verified: boolean;
    command: Command;
    file: File;
    /**
     * [申请事件 | EventType](https://github.com/project-mirai/mirai-api-http/blob/master/docs/EventType.md#%E7%94%B3%E8%AF%B7%E4%BA%8B%E4%BB%B6)
     */
    resp: Resp;
    logger: consola.ConsolaInstance;
    constructor(mirai: Mirai, axios: AxiosStatic);
    /**
     * 拦截 mirai 错误信息
     */
    handleStatusCode(): Promise<void>;
    /**
     * 使用此方法获取插件的信息，如版本号
     * @example data.data: { "version": "v1.0.0" }
     */
    about(): Promise<About>;
    /**
     * 使用此方法验证你的身份，并返回一个会话
     */
    verify(verifyKey?: string): Promise<Auth>;
    /**
     * 使用此方法校验并激活你的Session，同时将Session与一个已登录的Bot绑定
     */
    bind(qq: number): Promise<BaseResponse>;
    /**
     * 使用此方式释放 session 及其相关资源（Bot不会被释放） 不使用的 Session 应当被释放，长时间（30分钟）未使用的 Session 将自动释放。
     * 否则 Session 持续保存Bot收到的消息，将会导致内存泄露(开启websocket后将不会自动释放)
     */
    release(qq?: number): Promise<BaseResponse>;
    /**
     * 使用此方法获取 bot 接收到的最老消息和最老各类事件(会从 MiraiApiHttp 消息记录中删除)
     * @example { code: 0, data: [] }
     * @param count 获取消息和事件的数量
     */
    fetchMessage(count?: number): Promise<FetchMessage>;
    /**
     * 使用此方法获取 bot 接收到的最新消息和最新各类事件(会从 MiraiApiHttp 消息记录中删除)
     * @param count 获取消息和事件的数量
     */
    fetchLatestMessage(count?: number): Promise<FetchMessage>;
    /**
     * 使用此方法获取 bot 接收到的最老消息和最老各类事件(不会从 MiraiApiHttp 消息记录中删除)
     * @param count 获取消息和事件的数量
     */
    peekMessage(count?: number): Promise<FetchMessage>;
    /**
     * 使用此方法获取 bot 接收到的最老消息和最老各类事件(不会从 MiraiApiHttp 消息记录中删除)
     * @param count 获取消息和事件的数量
     */
    peekLatestMessage(count?: number): Promise<FetchMessage>;
    /**
     * 通过 messageId 获取一条被缓存的消息
     * @param messageId 获取消息的 messageId
     * @param target 好友 ID 或 群 ID
     */
    messageFromId(messageId: number, target: number): Promise<MessageType.ChatMessage | MessageFromId>;
    /**
     * 使用此方法向指定好友发送消息
     * @param messageChain 消息链，是一个消息对象构成的数组
     * @param target 发送消息目标好友的 QQ 号
     * @param quote 引用一条消息的messageId进行回复
     * @returns { code: 0, msg: "success", messageId: 123456 } messageId 一个Int类型属性，标识本条消息，用于撤回和引用回复
     */
    sendFriendMessage(messageChain: string | MessageType.MessageChain, target: number, quote?: number): Promise<SendMessage>;
    /**
     * 使用此方法向指定群发送消息
     * @param messageChain 消息链，是一个消息对象构成的数组
     * @param target 发送消息目标群的群号
     * @param quote 引用一条消息的messageId进行回复
     * @return { code: 0, msg: "success", messageId: 123456 } messageId 一个Int类型属性，标识本条消息，用于撤回和引用回复
     */
    sendGroupMessage(messageChain: string | MessageType.MessageChain, target: number, quote?: number): Promise<SendMessage>;
    /**
     * 发送临时会话消息
     * @param messageChain 消息链，是一个消息对象构成的数组
     * @param qq 临时会话对象QQ号
     * @param group 临时会话群号
     * @param quote 引用一条消息的messageId进行回复
     */
    sendTempMessage(messageChain: string | MessageType.MessageChain, qq: number, group: number, quote?: number): Promise<SendMessage>;
    /**
     * 使用此方法向指定对象（群或好友）发送图片消息 除非需要通过此手段获取imageId，否则不推荐使用该接口
     * @param urls 是一个url字符串构成的数组
     * @param target 发送对象的QQ号或群号，可能存在歧义
     * @param qq 发送对象的QQ号
     * @param group 发送对象的群号
     */
    sendImageMessage(urls: string[], target?: number, qq?: number, group?: number): Promise<string[]>;
    /**
     * 使用此方法上传图片文件至服务器并返回 ImageId
     * @param type
     * @param img 图片文件 fs.createReadStream(img)
     */
    uploadImage(type: 'friend' | 'group' | 'temp', img: File): Promise<UploadImage>;
    /**
     * 使用此方法上传语音文件至服务器并返回 VoiceId
     * @param type 当前仅支持 "group"
     * @param voice 语音文件 fs.createReadStream(voice)
     */
    uploadVoice(type: 'friend' | 'group' | 'temp', voice: File): Promise<UploadVoice>;
    /**
     * 文件上传
     * @param type 当前仅支持 "Group"
     * @param target 指定群的群号
     * @param path 文件上传目录与名字
     * @param file 文件内容
     */
    uploadFileAndSend(type: 'Group', target: number, path: string, file: File): Promise<any>;
    /**
     * 撤回消息
     * 使用此方法撤回指定消息。对于bot发送的消息，有2分钟时间限制。对于撤回群聊中群员的消息，需要有相应权限
     * @desc mirai 更新强制需要 messageId + target
     * @param params { messageId, target }
     */
    recall(params: RecallParams | MessageType.ChatMessage): Promise<BaseResponse>;
    /**
     * 获取 bot 的好友列表
     */
    friendList(): Promise<FriendList>;
    /**
     * 获取 bot 的群列表
     */
    groupList(): Promise<GroupList>;
    /**
     * 获取 BOT 的群成员列表
     * @param target 指定群的群号
     */
    memberList(target: number): Promise<MemberList>;
    /**
     * 此接口获取 session 绑定 bot 的详细资料
     */
    botProfile(): Promise<UserProfile>;
    /**
     * 此接口获取好友的详细资料
     * @param target 好友 QQ 号
     */
    friendProfile(target: number): Promise<UserProfile>;
    /**
     * 此接口获取群成员的消息资料
     * @param target 指定群的群号
     * @param memberId 群成员 QQ 号
     */
    memberProfile(target: number, memberId: number): Promise<UserProfile>;
    /**
     * 指定群进行全体禁言
     * @param target 指定群的群号
     */
    muteAll(target: MuteAll['target']): Promise<BaseResponse>;
    /**
     * 指定群解除全体禁言
     * @param target 指定群的群号
     */
    unmuteAll(target: UnmuteAll['target']): Promise<BaseResponse>;
    /**
     * 指定群禁言指定群员
     * @param target 指定群的群号
     * @param memberId 指定群员QQ号
     * @param time 禁言时长，单位为秒，最多30天，默认为 60 秒
     */
    mute(target: number, memberId: number, time?: number): Promise<BaseResponse>;
    /**
     * 指定群解除群成员禁言
     * @param target 指定群的群号
     * @param memberId 指定群员QQ号
     */
    unmute(target: number, memberId: number): Promise<BaseResponse>;
    /**
     * 移除群成员
     * @param target 指定群的群号
     * @param memberId 指定群员QQ号
     * @param msg 信息
     */
    kick(target: number, memberId: number, msg?: string): Promise<BaseResponse>;
    /**
     * 退出群聊
     * @param target 群号
     * bot为该群群主时退出失败并返回code 10(无操作权限)
     */
    quit(target: number): Promise<BaseResponse>;
    /**
     * 传入 config 时，修改群设置
     * 未传入 config 时，获取群设置
     * @param target 指定群的群号
     * @param config 群设置
     */
    groupConfig(target: number, config?: GroupConfig$1): Promise<GroupConfig$1 | BaseResponse>;
    /**
     * 传入 info 时，修改群员资料
     * 未传入 info 时，获取群员资料
     * @param target 指定群的群号
     * @param memberId 群员QQ号
     * @param info 群员资料
     */
    memberInfo(target: number, memberId: number, info?: MemberInfo['info']): Promise<MemberInfo$1 | BaseResponse>;
    /**
     * 构建 WebSocket 通道
     * @param type
     */
    private _buildWsChannel;
    /**
     * 监听该接口，插件将推送 Bot 收到的消息
     * @param callback 回调函数
     */
    message(callback: WsCallbackMap['message']): void;
    /**
     * 监听该接口，插件将推送 Bot 收到的事件
     * @param callback 回调函数
     */
    event(callback: WsCallbackMap['event']): void;
    /**
     * 监听该接口，插件将推送 Bot 收到的消息和事件
     * @param callback 回调函数
     */
    all(callback: WsCallbackMap['all']): void;
    /**
     * 获取 Mangers
     */
    managers(): Promise<number[]>;
    /**
     * 设置群精华消息
     * @param target 消息ID
     */
    setEssence(target: number): Promise<BaseResponse>;
    /**
     * 戳一戳
     * @param target 戳一戳的目标, QQ号, 可以为 bot QQ号
     * @param subject 戳一戳接受主体(上下文), 戳一戳信息会发送至该主体, 为群号/好友QQ号
     * @param kind 上下文类型
     */
    sendNudge(target: number, subject: number, kind?: SendNudge['kind']): Promise<BaseResponse>;
}

/**
 * - `0` 同意添加好友
 * - `1` 拒绝添加好友
 * - `2` 拒绝添加好友并添加黑名单，不再接收该用户的好友申请
 */
declare enum NewFriendRequestOperationType {
    /**
     * 同意添加好友
     */
    Accept = 0,
    /**
     * 拒绝添加好友
     */
    Refuse = 1,
    /**
     * 拒绝添加好友并添加黑名单，不再接收该用户的好友申请
     */
    RefuseAndBlock = 2
}
/**
 * - `0` 同意入群
 * - `1` 拒绝入群
 * - `2` 忽略请求
 * - `3` 拒绝入群并添加黑名单，不再接收该用户的入群申请
 * - `4` 忽略入群并添加黑名单，不再接收该用户的入群申请
 */
declare enum MemberJoinRequestOperationType {
    /**
     * 同意入群
     */
    Accept = 0,
    /**
     * 拒绝入群
     */
    Refuse = 1,
    /**
     * 忽略请求
     */
    Ignore = 2,
    /**
     * 拒绝入群并添加黑名单，不再接收该用户的入群申请
     */
    RefuseAndBlock = 3,
    /**
     * 忽略入群并添加黑名单，不再接收该用户的入群申请
     */
    IgnoreAndBlock = 4
}
/**
 * - `0` 同意邀请
 * - `1` 拒绝邀请
 */
declare enum BotInvitedJoinGroupRequestOperationType {
    /**
     * 同意邀请
     */
    Accept = 0,
    /**
     * 拒绝邀请
     */
    Refuse = 1
}
/**
 * [申请事件 | EventType](https://github.com/project-mirai/mirai-api-http/blob/master/docs/EventType.md#%E7%94%B3%E8%AF%B7%E4%BA%8B%E4%BB%B6)
 * Example: resp.newFriendRequest for `/resp/newFriendRequestEvent`
 */
declare class Resp {
    private api;
    constructor(api: MiraiApiHttp);
    _request(event: RequestEvent, operate: number, message?: string): Promise<NewFriendRequestEvent | MemberJoinRequestEvent | BotInvitedJoinGroupRequestEvent>;
    /**
     * 响应新朋友请求
     * @param event 请求的事件
     * @param operate 操作：0 同意添加好友, 1 拒绝添加好友, 2 拒绝添加好友并添加黑名单，不再接收该用户的好友申请
     * @param message 响应消息
     */
    newFriendRequest(event: NewFriendRequestEvent$1, operate: NewFriendRequestOperationType, message?: string): Promise<NewFriendRequestEvent>;
    /**
     * 响应新入群请求
     * @param event 请求的事件
     * @param operate 操作: 0 同意入群, 1 拒绝入群, 2 忽略请求, 3 拒绝入群并添加黑名单，不再接收该用户的入群申请, 4 忽略入群并添加黑名单，不再接收该用户的入群申请
     * @param message 响应消息
     */
    memberJoinRequest(event: MemberJoinRequestEvent$1, operate: MemberJoinRequestOperationType, message?: string): Promise<MemberJoinRequestEvent>;
    /**
     * 响应被邀请入群申请
     * @param event 请求的事件
     * @param operate 操作：0 同意邀请, 1 拒绝邀请
     * @param message 响应消息
     */
    botInvitedJoinGroupRequest(event: BotInvitedJoinGroupRequestEvent$1, operate: BotInvitedJoinGroupRequestOperationType, message?: string): Promise<BotInvitedJoinGroupRequestEvent>;
}

/**
 * 事件类型，与 [mirai-api-http 事件类型一览](https://github.com/project-mirai/mirai-api-http/blob/master/docs/EventType.md) 保持一致
 * @packageDocumentation
 */

/**
 * 内部基类
 */
interface BaseEvent {
    type: string;
    /**
     * reply 辅助函数
     */
    reply?: (msgChain: string | MessageType.MessageChain, quote?: boolean) => Promise<void>;
}
/**
 * Bot 登录成功
 */
interface BotOnlineEvent extends BaseEvent {
    type: 'BotOnlineEvent';
    qq: number;
}
/**
 * Bot 主动离线
 */
interface BotOfflineEventActive extends BaseEvent {
    type: 'BotOfflineEventActive';
    qq: number;
}
/**
 * Bot被挤下线
 */
interface BotOfflineEventForce extends BaseEvent {
    type: 'BotOfflineEventForce';
    qq: number;
}
/**
 * Bot被服务器断开或因网络问题而掉线
 */
interface BotOfflineEventDropped extends BaseEvent {
    type: 'BotOfflineEventDropped';
    qq: number;
}
/**
 * Bot主动重新登录.
 */
interface BotReloginEvent extends BaseEvent {
    type: 'BotReloginEvent';
    qq: number;
}
/**
 * 群消息撤回
 */
interface GroupRecallEvent extends BaseEvent {
    type: 'GroupRecallEvent';
    authorId: number;
    messageId: number;
    time: number;
    group: Group;
    operator: Member | null;
}
/**
 * 好友消息撤回
 */
interface FriendRecallEvent extends BaseEvent {
    type: 'FriendRecallEvent';
    authorId: number;
    messageId: number;
    time: number;
    operator: number;
}
/**
 * Bot在群里的权限被改变. 操作人一定是群主
 */
interface BotGroupPermissionChangeEvent extends BaseEvent {
    type: 'BotGroupPermissionChangeEvent';
    origin: Permission;
    current: Permission;
    group: Group;
}
/**
 * Bot被禁言
 */
interface BotMuteEvent extends BaseEvent {
    type: 'BotMuteEvent';
    durationSeconds: number;
    operator: Member;
}
/**
 * Bot被取消禁言
 */
interface BotUnmuteEvent extends BaseEvent {
    type: 'BotUnmuteEvent';
    operator: Member;
}
/**
 * Bot加入了一个新群
 */
interface BotJoinGroupEvent extends BaseEvent {
    type: 'BotJoinGroupEvent';
    group: Group;
}
/**
 * Bot主动退出一个群
 */
interface BotLeaveEventActive extends BaseEvent {
    type: 'BotLeaveEventActive';
    group: Group;
}
/**
 * Bot被踢出一个群
 */
interface BotLeaveEventKick extends BaseEvent {
    type: 'BotLeaveEventKick';
    group: Group;
}
/**
 * 某个群名改变
 */
interface GroupNameChangeEvent extends BaseEvent {
    type: 'GroupNameChangeEvent';
    origin: string;
    current: string;
    group: Group;
    operator: Member | null;
}
/**
 * 某群入群公告改变
 */
interface GroupEntranceAnnouncementChangeEvent extends BaseEvent {
    type: 'GroupEntranceAnnouncementChangeEvent';
    origin: string;
    current: string;
    group: Group;
    operator: Member | null;
}
/**
 * 全员禁言
 */
interface GroupMuteAllEvent extends BaseEvent {
    type: 'GroupMuteAllEvent';
    origin: boolean;
    current: boolean;
    group: Group;
    operator: Member | null;
}
/**
 * 匿名聊天
 */
interface GroupAllowAnonymousChatEvent extends BaseEvent {
    type: 'GroupAllowAnonymousChatEvent';
    origin: boolean;
    current: boolean;
    group: Group;
    operator: Member | null;
}
/**
 * 坦白说
 */
interface GroupAllowConfessTalkEvent extends BaseEvent {
    type: 'GroupAllowConfessTalkEvent';
    origin: boolean;
    current: boolean;
    group: Member;
    isByBot: boolean;
}
/**
 * 允许群员邀请好友加群
 */
interface GroupAllowMemberInviteEvent extends BaseEvent {
    type: 'GroupAllowMemberInviteEvent';
    origin: boolean;
    current: boolean;
    group: Group;
    operator: Member | null;
}
/**
 * 新人入群的事件
 */
interface MemberJoinEvent extends BaseEvent {
    type: 'MemberJoinEvent';
    member: Member;
}
/**
 * 成员被踢出群（该成员不是Bot）
 */
interface MemberLeaveEventKick extends BaseEvent {
    type: 'MemberLeaveEventKick';
    member: Member;
    operator: Member | null;
}
/**
 * 成员主动离群（该成员不是Bot）
 */
interface MemberLeaveEventQuit extends BaseEvent {
    type: 'MemberLeaveEventQuit';
    member: Member;
}
/**
 * 群名片改动
 */
interface MemberCardChangeEvent extends BaseEvent {
    type: 'MemberCardChangeEvent';
    origin: string;
    current: string;
    member: Member;
    operator: Member | null;
}
/**
 * 群头衔改动（只有群主有操作限权）
 */
interface MemberSpecialTitleChangeEvent extends BaseEvent {
    type: 'MemberSpecialTitleChangeEvent';
    origin: string;
    current: string;
    member: Member;
}
/**
 * 成员权限改变的事件（该成员不可能是Bot，见 BotGroupPermissionChangeEvent）
 */
interface MemberPermissionChangeEvent extends BaseEvent {
    type: 'MemberPermissionChangeEvent';
    origin: Permission;
    current: Permission;
    member: Member;
}
/**
 * 群成员被禁言事件（该成员不可能是Bot，见 BotMuteEvent）
 */
interface MemberMuteEvent extends BaseEvent {
    type: 'MemberMuteEvent';
    durationSeconds: number;
    member: Member;
    operator: Member | null;
}
/**
 * 群成员被取消禁言事件（该成员不可能是Bot，见 BotUnmuteEvent）
 */
interface MemberUnmuteEvent extends BaseEvent {
    type: 'MemberUnmuteEvent';
    member: Member;
    operator: Member | null;
}
/**
 * 基础请求事件格式
 */
interface BaseRequestEvent$1 extends BaseEvent {
    /**
     * 事件标识，响应该事件时的标识
     */
    eventId: number;
}
/**
 * 添加好友申请
 */
interface NewFriendRequestEvent$1 extends BaseRequestEvent$1 {
    type: 'NewFriendRequestEvent';
    /**
     * 申请人QQ号
     */
    fromId: number;
    /**
     * 申请人如果通过某个群添加好友，该项为该群群号；否则为 0
     */
    groupId: number;
    /**
     * 申请人的昵称或群名片
     */
    nick: string;
    /**
     * 申请消息
     */
    message: string;
    respond: (operate: NewFriendRequestOperationType, message?: string) => Promise<NewFriendRequestEvent>;
}
/**
 * 用户入群申请（Bot需要有管理员权限）
 */
interface MemberJoinRequestEvent$1 extends BaseRequestEvent$1 {
    type: 'MemberJoinRequestEvent';
    /**
     * 申请人 QQ号
     */
    fromId: number;
    /**
     * 申请人申请入群的群号
     */
    groupId: number;
    /**
     * 申请人申请入群的群名称
     */
    groupName: string;
    /**
     * 申请人的昵称或群名片
     */
    nick: string;
    /**
     * 申请消息
     */
    message: string;
    respond: (operate: MemberJoinRequestOperationType, message?: string) => Promise<MemberJoinRequestEvent>;
}
/**
 * Bot被邀请入群申请
 */
interface BotInvitedJoinGroupRequestEvent$1 extends BaseRequestEvent$1 {
    type: 'BotInvitedJoinGroupRequestEvent';
    /**
     * 邀请人（好友）的 QQ号
     */
    fromId: number;
    /**
     * 被邀请进入群的群号
     */
    groupId: number;
    /**
     * 被邀请进入群的群名称
     */
    groupName: string;
    /**
     * 邀请人（好友）的昵称
     */
    nick: string;
    /**
     * 邀请消息
     */
    message: string;
    respond: (operate: BotInvitedJoinGroupRequestOperationType, message?: string) => Promise<BotInvitedJoinGroupRequestEvent>;
}
type RequestEvent = NewFriendRequestEvent$1 | MemberJoinRequestEvent$1 | BotInvitedJoinGroupRequestEvent$1;
type RequestEventType = RequestEvent['type'];
interface NudgeEvent extends BaseEvent {
    type: 'NudgeEvent';
    /**
     * 戳一戳发起人 QQ 号
     */
    fromId: number;
    /**
     * 被戳人的 QQ 号
     */
    target: number;
    /**
     * 动作，如：戳一戳
     */
    action: string;
    /**
     * 后缀，如：脸
     */
    suffix: string;
    /**
     * 戳一戳事件发生的主体 (上下文)
     */
    subject: {
        /**
         * 事件发生主体的 ID (群号 / 好友 QQ 号)
         */
        id: number;
        /**
         * 戳一戳事件发生的主体的类型
         */
        kind: 'Friend' | 'Group';
    };
}
interface CommandExecutedEvent extends BaseEvent {
    type: 'CommandExecutedEvent';
    /**
     * 命令名称
     */
    name: string;
    /**
     * 发送命令的好友, 从控制台发送为 null
     */
    friend: Friend | null;
    /**
     * 发送命令的群成员, 从控制台发送为 null
     */
    member: Member | null;
    /**
     * 指令的参数, 以消息类型传递
     */
    args: MessageType.MessageChain;
    reply?: undefined;
}
interface EventMap {
    BotOnlineEvent: BotOnlineEvent;
    BotOfflineEventActive: BotOfflineEventActive;
    BotOfflineEventForce: BotOfflineEventForce;
    BotOfflineEventDropped: BotOfflineEventDropped;
    BotReloginEvent: BotReloginEvent;
    GroupRecallEvent: GroupRecallEvent;
    FriendRecallEvent: FriendRecallEvent;
    BotGroupPermissionChangeEvent: BotGroupPermissionChangeEvent;
    BotMuteEvent: BotMuteEvent;
    BotUnmuteEvent: BotUnmuteEvent;
    BotJoinGroupEvent: BotJoinGroupEvent;
    BotLeaveEventActive: BotLeaveEventActive;
    BotLeaveEventKick: BotLeaveEventKick;
    GroupNameChangeEvent: GroupNameChangeEvent;
    GroupEntranceAnnouncementChangeEvent: GroupEntranceAnnouncementChangeEvent;
    GroupMuteAllEvent: GroupMuteAllEvent;
    GroupAllowAnonymousChatEvent: GroupAllowAnonymousChatEvent;
    GroupAllowConfessTalkEvent: GroupAllowConfessTalkEvent;
    GroupAllowMemberInviteEvent: GroupAllowMemberInviteEvent;
    MemberJoinEvent: MemberJoinEvent;
    MemberLeaveEventKick: MemberLeaveEventKick;
    MemberLeaveEventQuit: MemberLeaveEventQuit;
    MemberCardChangeEvent: MemberCardChangeEvent;
    MemberSpecialTitleChangeEvent: MemberSpecialTitleChangeEvent;
    MemberPermissionChangeEvent: MemberPermissionChangeEvent;
    MemberMuteEvent: MemberMuteEvent;
    MemberUnmuteEvent: MemberUnmuteEvent;
    NewFriendRequestEvent: NewFriendRequestEvent$1;
    MemberJoinRequestEvent: MemberJoinRequestEvent$1;
    BotInvitedJoinGroupRequestEvent: BotInvitedJoinGroupRequestEvent$1;
    NudgeEvent: NudgeEvent;
    CommandExecutedEvent: CommandExecutedEvent;
}
type EventType = keyof EventMap;
type Event = EventMap[EventType];

type eventType_BaseEvent = BaseEvent;
type eventType_BotGroupPermissionChangeEvent = BotGroupPermissionChangeEvent;
type eventType_BotJoinGroupEvent = BotJoinGroupEvent;
type eventType_BotLeaveEventActive = BotLeaveEventActive;
type eventType_BotLeaveEventKick = BotLeaveEventKick;
type eventType_BotMuteEvent = BotMuteEvent;
type eventType_BotOfflineEventActive = BotOfflineEventActive;
type eventType_BotOfflineEventDropped = BotOfflineEventDropped;
type eventType_BotOfflineEventForce = BotOfflineEventForce;
type eventType_BotOnlineEvent = BotOnlineEvent;
type eventType_BotReloginEvent = BotReloginEvent;
type eventType_BotUnmuteEvent = BotUnmuteEvent;
type eventType_CommandExecutedEvent = CommandExecutedEvent;
type eventType_Event = Event;
type eventType_EventMap = EventMap;
type eventType_EventType = EventType;
type eventType_FriendRecallEvent = FriendRecallEvent;
type eventType_GroupAllowAnonymousChatEvent = GroupAllowAnonymousChatEvent;
type eventType_GroupAllowConfessTalkEvent = GroupAllowConfessTalkEvent;
type eventType_GroupAllowMemberInviteEvent = GroupAllowMemberInviteEvent;
type eventType_GroupEntranceAnnouncementChangeEvent = GroupEntranceAnnouncementChangeEvent;
type eventType_GroupMuteAllEvent = GroupMuteAllEvent;
type eventType_GroupNameChangeEvent = GroupNameChangeEvent;
type eventType_GroupRecallEvent = GroupRecallEvent;
type eventType_MemberCardChangeEvent = MemberCardChangeEvent;
type eventType_MemberJoinEvent = MemberJoinEvent;
type eventType_MemberLeaveEventKick = MemberLeaveEventKick;
type eventType_MemberLeaveEventQuit = MemberLeaveEventQuit;
type eventType_MemberMuteEvent = MemberMuteEvent;
type eventType_MemberPermissionChangeEvent = MemberPermissionChangeEvent;
type eventType_MemberSpecialTitleChangeEvent = MemberSpecialTitleChangeEvent;
type eventType_MemberUnmuteEvent = MemberUnmuteEvent;
type eventType_NudgeEvent = NudgeEvent;
type eventType_RequestEvent = RequestEvent;
type eventType_RequestEventType = RequestEventType;
declare namespace eventType {
  export {
    eventType_BaseEvent as BaseEvent,
    eventType_BotGroupPermissionChangeEvent as BotGroupPermissionChangeEvent,
    BotInvitedJoinGroupRequestEvent$1 as BotInvitedJoinGroupRequestEvent,
    eventType_BotJoinGroupEvent as BotJoinGroupEvent,
    eventType_BotLeaveEventActive as BotLeaveEventActive,
    eventType_BotLeaveEventKick as BotLeaveEventKick,
    eventType_BotMuteEvent as BotMuteEvent,
    eventType_BotOfflineEventActive as BotOfflineEventActive,
    eventType_BotOfflineEventDropped as BotOfflineEventDropped,
    eventType_BotOfflineEventForce as BotOfflineEventForce,
    eventType_BotOnlineEvent as BotOnlineEvent,
    eventType_BotReloginEvent as BotReloginEvent,
    eventType_BotUnmuteEvent as BotUnmuteEvent,
    eventType_CommandExecutedEvent as CommandExecutedEvent,
    eventType_Event as Event,
    eventType_EventMap as EventMap,
    eventType_EventType as EventType,
    eventType_FriendRecallEvent as FriendRecallEvent,
    eventType_GroupAllowAnonymousChatEvent as GroupAllowAnonymousChatEvent,
    eventType_GroupAllowConfessTalkEvent as GroupAllowConfessTalkEvent,
    eventType_GroupAllowMemberInviteEvent as GroupAllowMemberInviteEvent,
    eventType_GroupEntranceAnnouncementChangeEvent as GroupEntranceAnnouncementChangeEvent,
    eventType_GroupMuteAllEvent as GroupMuteAllEvent,
    eventType_GroupNameChangeEvent as GroupNameChangeEvent,
    eventType_GroupRecallEvent as GroupRecallEvent,
    eventType_MemberCardChangeEvent as MemberCardChangeEvent,
    eventType_MemberJoinEvent as MemberJoinEvent,
    MemberJoinRequestEvent$1 as MemberJoinRequestEvent,
    eventType_MemberLeaveEventKick as MemberLeaveEventKick,
    eventType_MemberLeaveEventQuit as MemberLeaveEventQuit,
    eventType_MemberMuteEvent as MemberMuteEvent,
    eventType_MemberPermissionChangeEvent as MemberPermissionChangeEvent,
    eventType_MemberSpecialTitleChangeEvent as MemberSpecialTitleChangeEvent,
    eventType_MemberUnmuteEvent as MemberUnmuteEvent,
    NewFriendRequestEvent$1 as NewFriendRequestEvent,
    eventType_NudgeEvent as NudgeEvent,
    eventType_RequestEvent as RequestEvent,
    eventType_RequestEventType as RequestEventType,
  };
}

/**
 * API 响应格式
 * @packageDocumentation
 */

interface FetchMessage {
    code: number;
    data: (MessageType.ChatMessage | Event)[];
}
/**
 * 基础响应格式
 */
interface BaseResponse {
    code: number;
    msg: string;
}
interface ResponseType<T> extends BaseResponse {
    data: T;
}
interface SendMessage extends BaseResponse {
    /**
     * 一个Int类型属性，标识本条消息，用于撤回和引用回复
     */
    messageId: number;
}
type MessageFromId = ResponseType<MessageType.ChatMessage>;
interface Auth extends BaseResponse {
    /**
     * 状态码
     * 0: 正常
     * 1: 错误的 MIRAI API HTTP auth key
     */
    code: 0 | 1;
    /**
     * 你的 session key
     */
    session: string;
}
interface About extends BaseResponse {
    data: {
        version: string;
    };
}
interface UploadImage {
    imageId: string;
    url: string;
    path: string;
}
interface UploadVoice {
    voiceId: string;
    url: string;
    path: string;
}
type FriendList = ResponseType<Friend[]>;
type GroupList = ResponseType<Group[]>;
type MemberList = ResponseType<Member[]>;
interface BaseRequestEvent {
    /**
     * session key
     */
    sessionKey: string;
    /**
     * 事件标识
     */
    eventId: number;
    /**
     * 发起者 QQ
     */
    fromId: number;
    /**
     * 来源群号
     */
    groupId: number;
    /**
     * 响应的操作类型
     */
    operate: number;
    /**
     * 回复的信息
     */
    message: string;
}
interface NewFriendRequestEvent extends BaseRequestEvent {
    operate: NewFriendRequestOperationType;
}
interface MemberJoinRequestEvent extends BaseRequestEvent {
    operate: MemberJoinRequestOperationType;
}
interface BotInvitedJoinGroupRequestEvent extends BaseRequestEvent {
    operate: BotInvitedJoinGroupRequestOperationType;
}

type response_About = About;
type response_Auth = Auth;
type response_BaseRequestEvent = BaseRequestEvent;
type response_BaseResponse = BaseResponse;
type response_BotInvitedJoinGroupRequestEvent = BotInvitedJoinGroupRequestEvent;
type response_FetchMessage = FetchMessage;
type response_FriendList = FriendList;
type response_GroupList = GroupList;
type response_MemberJoinRequestEvent = MemberJoinRequestEvent;
type response_MemberList = MemberList;
type response_MessageFromId = MessageFromId;
type response_NewFriendRequestE