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_NewFriendRequestEvent = NewFriendRequestEvent;
type response_ResponseType<T> = ResponseType<T>;
type response_SendMessage = SendMessage;
type response_UploadImage = UploadImage;
type response_UploadVoice = UploadVoice;
declare namespace response {
  export {
    response_About as About,
    response_Auth as Auth,
    response_BaseRequestEvent as BaseRequestEvent,
    response_BaseResponse as BaseResponse,
    response_BotInvitedJoinGroupRequestEvent as BotInvitedJoinGroupRequestEvent,
    response_FetchMessage as FetchMessage,
    response_FriendList as FriendList,
    response_GroupList as GroupList,
    response_MemberJoinRequestEvent as MemberJoinRequestEvent,
    response_MemberList as MemberList,
    response_MessageFromId as MessageFromId,
    response_NewFriendRequestEvent as NewFriendRequestEvent,
    response_ResponseType as ResponseType,
    response_SendMessage as SendMessage,
    response_UploadImage as UploadImage,
    response_UploadVoice as UploadVoice,
  };
}

/**
 * 所有消息
 */
type MessageAndEvent = MessageType.ChatMessage | Event;
/**
 * 所有消息类型
 */
type MessageAndEventType = MessageType.ChatMessageType | EventType;
/**
 * 数据类型
 */
type Data<T extends 'message' | EventType | MessageType.ChatMessageType> = T extends EventType ? EventMap[T] : T extends MessageType.ChatMessageType ? MessageType.ChatMessageMap[T] : MessageType.ChatMessage;
type SendMessageType = 'friend' | 'group';
/**
 * Mirai SDK 初始化类
 */
declare class Mirai {
    mahSetting: MiraiApiHttpSetting;
    options: MiraiOptions;
    /**
     * 封装 mirai-api-http 的固有方法
     */
    api: MiraiApiHttp;
    /**
     * 日志模块
     */
    logger: consola.ConsolaInstance;
    /**
     * 请求工具
     */
    axios: AxiosStatic;
    qq: number;
    /**
     * 是否验证成功
     */
    verified: boolean;
    /**
     * 监听器状态（false 则不执行监听器回调函数）
     */
    active: boolean;
    /**
     * 监听者之前执行的函数
     */
    beforeListener: Function[];
    /**
     * 监听者之后执行的函数
     */
    afterListener: Function[];
    /**
     * 轮询获取消息的时间间隔，默认 200 ms，仅在未开启 Websocket 时有效
     */
    interval: number;
    /**
     * fetchMessage 重试次数
     */
    retries: number;
    /**
     * 当前处理的消息
     */
    curMsg?: MessageType.ChatMessage | Event;
    /**
     * 事件触发器
     */
    eventEmitter: events<[never]>;
    constructor(userMahSetting?: Partial<MiraiApiHttpSetting>, userOptions?: MiraiOptions);
    about(): Promise<void>;
    /**
     * link 链接 mirai 已经登录的 QQ 号
     */
    link(qq: number): Promise<BaseResponse>;
    /**
     * 获取 Session
     * data.code === 0 成功
     */
    verify(): Promise<Auth>;
    /**
     * 激活 Session，绑定 QQ
     * data.code === 0 成功
     */
    bind(): Promise<BaseResponse>;
    /**
     * 释放 Session
     */
    release(): Promise<BaseResponse>;
    /**
     * message 展开为 FriendMessage | GroupMessage | TempMessage
     * @param method
     * @param callback
     */
    _adaptMessageForAll<T extends 'message' | EventType | MessageType.ChatMessageType>(method: 'on' | 'off' | 'once', callback: (data: Data<T>) => any): void;
    /**
     * 绑定事件列表
     * message: FriendMessage | GroupMessage | TempMessage
     * [mirai-api-http事件类型一览](https://github.com/project-mirai/mirai-api-http/blob/master/docs/EventType.md)
     * @example mirai.on('MemberMuteEvent', ()=>{})
     * @param type
     * @param callback
     */
    on<T extends 'message' | EventType | MessageType.ChatMessageType>(type: T, callback: (data: Data<T>) => any): void;
    /**
     * 仅处理事件一次
     * @param type
     * @param callback
     */
    once<T extends 'message' | EventType | MessageType.ChatMessageType>(type: T, callback: (data: Data<T>) => any): void;
    /**
     * 取消监听器
     * @param type
     * @param callback
     */
    off<T extends 'message' | EventType | MessageType.ChatMessageType>(type: T, callback: (data: Data<T>) => any): void;
    /**
     * 快速回复（只在消息类型包含群组或好友信息时有效）
     * @param msgChain 发送内容（消息链/纯文本皆可）
     * @param srcMsg 回复哪条消息
     * @param quote 是否引用回复（非聊天消息类型时无效）
     */
    reply(msgChain: string | MessageType.MessageChain, srcMsg: Event | MessageType.ChatMessage, quote?: boolean): Promise<SendMessage | (SendMessage | undefined)[] | undefined>;
    /**
     * 根据消息类型发送消息
     * @param type
     * @param msgChain
     * @param target
     * @param messageId
     */
    _sendMessageByType(type: SendMessageType, msgChain: string | MessageType.MessageChain, target: number, messageId: number): Promise<SendMessage> | undefined;
    /**
     * 处理消息
     * @param msg
     */
    handle(msg: MessageType.ChatMessage | Event): void;
    /**
     * 在监听器函数执行前执行
     */
    before(callback: Function): void;
    /**
     * 在监听器函数执行后执行
     */
    after(callback: Function): void;
    /**
     * 监听消息和事件
     */
    listen(): void;
}

/**
 * 生成对应消息格式
 * @packageDocumentation
 */

/**
 * 生成引用的消息格式
 * @param messageId 消息 ID
 */
declare function Quote(messageId: number): MessageType.Quote;
/**
 * 生成艾特默认的消息格式
 * @param target QQ 号
 */
declare function At(target: number): MessageType.At;
/**
 * 生成艾特全体成员的消息格式
 */
declare function AtAll(): MessageType.AtAll;
/**
 * 生成 QQ 原生表情消息格式
 * @param faceId QQ表情编号
 * @param name QQ表情拼音，可选
 */
declare function Face(faceId: number, name?: string): MessageType.Face;
/**
 * 生成文本消息格式
 * @param text 文本
 */
declare function Plain(text: string): MessageType.Plain;
/**
 * 生成图片消息格式
 * @param imageId 图片的imageId，群图片与好友图片格式不同。不为空时将忽略url属性
 * @param url 图片的URL，发送时可作网络图片的链接；接收时为腾讯图片服务器的链接，可用于图片下载
 * @param path 图片的路径，发送本地图片，相对路径于 `data/net.mamoe.mirai-api-http/images`
 * @param base64 图片的 Base64 编码
 */
declare function Image(imageId?: string | null, url?: string | null, path?: string | null, base64?: string | null): MessageType.Image;
/**
 * 生成闪照消息格式
 * @param imageId 图片的imageId，群图片与好友图片格式不同。不为空时将忽略url属性
 * @param url 图片的URL，发送时可作网络图片的链接；接收时为腾讯图片服务器的链接，可用于图片下载
 * @param path 图片的路径，发送本地图片，相对路径于 `data/net.mamoe.mirai-api-http/images`
 */
declare function FlashImage(imageId?: string | null, url?: string | null, path?: string | null): MessageType.FlashImage;
/**
 * 需要 mirai-api-http 1.8.2 以上，mirai-console 1.0 以上
 * 生成语音消息格式
 * @param voiceId 语音的 voiceId，不为空时将忽略 url 属性
 * @param url 语音的URL，发送时可作网络语音的链接；接收时为腾讯语音服务器的链接，可用于语音下载
 * @param path 语音的路径，发送本地语音，相对路径于 `data/net.mamoe.mirai-api-http/voices`
 */
declare function Voice(voiceId?: string | null, url?: string | null, path?: string | null, base64?: string | null): MessageType.Voice;
/**
 * 富文本消息（譬如合并转发）
 * @param xml
 */
declare function Xml(xml: string): MessageType.Xml;
/**
 * Json 消息格式（我也还没看懂这哪里用，欢迎 PR）
 * @param json
 */
declare function Json(json: string): MessageType.Json;
/**
 * 小程序
 * @param content
 */
declare function App(content: string): MessageType.App;
/**
 * - "Poke": 戳一戳
 * - "ShowLove": 比心
 * - "Like": 点赞
 * - "Heartbroken": 心碎
 * - "SixSixSix": 666
 * - "FangDaZhao": 放大招
 * @param name 戳一戳的类型
 */
declare function Poke(name: MessageType.PokeName): MessageType.Poke;
/**
 * 音乐分享
 * @param kind 音乐应用类型
 * @param title 消息卡片标题
 * @param summary 消息卡片内容
 * @param jumpUrl 点击卡片跳转网页 URL
 * @param pictureUrl 消息卡片图片 URL
 * @param musicUrl 音乐文件 URL
 * @param brief 在消息列表显示，可选，默认为 `[分享]$title`
 */
declare function MusicShare(kind: MessageType.MusicShareKind, title: string, summary: string, jumpUrl: string, pictureUrl: string, musicUrl: string, brief?: string): MessageType.MusicShare;

declare const message_App: typeof App;
declare const message_At: typeof At;
declare const message_AtAll: typeof AtAll;
declare const message_Face: typeof Face;
declare const message_FlashImage: typeof FlashImage;
declare const message_Image: typeof Image;
declare const message_Json: typeof Json;
declare const message_MusicShare: typeof MusicShare;
declare const message_Plain: typeof Plain;
declare const message_Poke: typeof Poke;
declare const message_Quote: typeof Quote;
declare const message_Voice: typeof Voice;
declare const message_Xml: typeof Xml;
declare namespace message {
  export {
    message_App as App,
    message_At as At,
    message_AtAll as AtAll,
    message_Face as Face,
    message_FlashImage as FlashImage,
    message_Image as Image,
    message_Json as Json,
    message_MusicShare as MusicShare,
    message_Plain as Plain,
    message_Poke as Poke,
    message_Quote as Quote,
    message_Voice as Voice,
    message_Xml as Xml,
  };
}

/**
 * 消息匹配辅助函数，提供了默认的几种匹配检测方式，可以直接导入使用。
 * @packageDocumentation
 */

/**
 * 配置类型
 * @packageDocumentation
 */
/**
 * 正则表达式
 */
interface Re {
    pattern: string;
    flags?: string;
}
/**
 * 匹配配置
 */
interface Match {
    re?: Re | string;
    is?: string | string[];
    includes?: string | string[];
}
/**
 * 匹配是否相同，当 keywords 为数组时，代表或，有一个相同即可
 * @param str 字符串
 * @param keywords 关键字
 */
declare function is(str: string, keywords: string | string[]): boolean;
/**
 * 匹配是否包含，当 keywords 为数组时，代表同时包含
 * @param str 字符串
 * @param keywords  关键字
 */
declare function includes(str: string, keywords: string | string[]): boolean;
/**
 * 正则匹配（存在时，返回匹配的情况，不存在时返回 false）
 * @param str 字符
 * @param config 正则配置，可以是包含 pattern，flags 的对象，也可以是字符串（直接代表 pattern）
 */
declare function re(str: string, config: Re | string): RegExpMatchArray | boolean;
/**
 * 是否匹配
 * @param str 字符串
 * @param ans 回答的语法配置
 */
declare function match(str: string, ans: Match): boolean | RegExpMatchArray | null;
/**
 * 是否是聊天信息中的一种
 * ['FriendMessage', 'GroupMessage', 'TempMessage']
 * @param msg 消息链
 */
declare function isChatMessage(msg: MessageType.ChatMessage | Event | any): msg is MessageType.ChatMessage;
/**
 * 是否被艾特
 * 传入 qq 时，返回是否被艾特
 * 未传入 qq 时，返回艾特消息
 * @param msg
 */
declare function isAt(msg: MessageType.ChatMessage, qq?: number): boolean | MessageType.At;

type check_Match = Match;
type check_Re = Re;
declare const check_includes: typeof includes;
declare const check_is: typeof is;
declare const check_isAt: typeof isAt;
declare const check_isChatMessage: typeof isChatMessage;
declare const check_match: typeof match;
declare const check_re: typeof re;
declare namespace check {
  export {
    check_Match as Match,
    check_Re as Re,
    check_includes as includes,
    check_is as is,
    check_isAt as isAt,
    check_isChatMessage as isChatMessage,
    check_match as match,
    check_re as re,
  };
}

type BaseCardType = 'bilibili';
/**
 * 获取卡片类型
 * @param type
 */
declare function getInfoByType(type: BaseCardType): {
    icon: string;
    name: string;
};
/**
 * 卡片信息格式
 */
interface CardInfo {
    type?: BaseCardType;
    /**
     * 简介
     */
    brief?: string;
    /**
     * 卡片链接
     */
    url: string;
    /**
     * 卡片标题
     */
    title?: string;
    /**
     * 卡片摘要
     */
    summary?: string;
    /**
     * 卡片封面图
     */
    cover: string;
    /**
     * 卡片图标
     */
    icon?: string;
    /**
     * 卡片名称
     */
    name?: string;
}
/**
 * 生成卡片 XML 消息模版
 * @example
 * msg.reply([
 *   Message.Xml(
 *     template.card({
 *       type: "bilibili",
 *       url: "https://www.bilibili.com/video/BV1bs411b7aE",
 *       cover:
 *         "https://cdn.jsdelivr.net/gh/YunYouJun/cdn/img/meme/love-er-ci-yuan-is-sick.jpg",
 *       summary: "咱是摘要", // 从前有座山...
 *       title: "咱是标题", // 震惊，xxx！
 *       brief: "咱是简介", // QQ小程序[哔哩哔哩]
 *     })
 *   )
 * ]);
 * @param info
 */
declare function card(info: CardInfo): string;

type template_CardInfo = CardInfo;
declare const template_card: typeof card;
declare const template_getInfoByType: typeof getInfoByType;
declare namespace template {
  export {
    template_CardInfo as CardInfo,
    template_card as card,
    template_getInfoByType as getInfoByType,
  };
}

/**
 * mirai-ts 辅助工具
 * @packageDocumentation
 */

/**
 * 头像尺寸（允许传入的参数）
 */
type AvatarSize = 1 | 2 | 3 | 4 | 5 | 40 | 100 | 140 | 640;
/**
 * 获取 QQ 头像链接
 * @param id
 * @param type 类型
 * @param size 尺寸 px (其他数字测试无法获得头像)
 * - 1: 40*40
 * - 2: 40*40
 * - 3: 100*100
 * - 4: 140*140
 * - 5: 640*640
 * - 40: 40*40
 * - 100: 100*100
 */
declare function getAvatarById(id: number, type?: 'friend' | 'group', size?: AvatarSize): string | null;

/**
 * mirai-ts 默认导出内容
 * @packageDocumentation
 */

type MiraiInstance = Mirai;

export { Adapter, index as Api, AvatarSize, BaseFileOptions, BotInvitedJoinGroupRequestOperationType, Command, CommandInfo, config as Config, contact as Contact, Data, eventType as EventType, File, FileDeleteOptions, FileDeleteParams, FileInfo, FileInfoOptions, FileInfoParams, FileInfoResponse, FileListOptions, FileListResponse, FileMkdirOptions, FileMkdirParams, FileMoveOptions, FileMoveParams, FileRenameOptions, FileRenameParams, HttpAdapter, MemberJoinRequestOperationType, message as Message, MessageAndEvent, MessageAndEventType, MessageType, Mirai, MiraiApiHttp, MiraiApiHttpSetting, MiraiInstance, MiraiOptions, NewFriendRequestOperationType, Resp, ReverseWebsocketAdapter, SendMessageType, Sex, StatusCode, StatusCodeMap, UserProfile, WebhookAdapter, WebsocketAdapter, WsCallbackMap, check, Mirai as default, getAvatarById, getMessageFromStatusCode, template, toMessageChain };