@mrlingxd/koishi-plugin-adapter-onebot 0.1.0

package/lib/bot/qqguild.d.ts

@@ -0,0 +1,31 @@
+import { Context, Universal } from "koishi";
+import { BaseBot } from "./base";
+import { OneBotBot } from ".";
+import * as OneBot from "../utils";
+export declare namespace QQGuildBot {
+    interface Config extends BaseBot.Config {
+        parent: OneBotBot<Context>;
+        profile: OneBot.GuildServiceProfile;
+    }
+}
+export declare class QQGuildBot<C extends Context> extends BaseBot<C> {
+    parent: OneBotBot<Context>;
+    hidden: boolean;
+    constructor(ctx: C, config: QQGuildBot.Config);
+    get status(): Universal.Status;
+    set status(status: Universal.Status);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getChannel(channelId: string, guildId?: string): Promise<Universal.Channel>;
+    getChannelList(guildId: string): Promise<{
+        data: Universal.Channel[];
+    }>;
+    getGuild(guildId: string): Promise<Universal.Guild>;
+    getGuildList(): Promise<{
+        data: Universal.Guild[];
+    }>;
+    getGuildMember(guildId: string, userId: string): Promise<Universal.GuildMember>;
+    getGuildMemberList(guildId: string): Promise<{
+        data: Universal.GuildMember[];
+    }>;
+}

package/lib/bot/qqguild.js

@@ -0,0 +1,66 @@
+import { BaseBot } from "./base";
+import * as OneBot from "../utils";
+export class QQGuildBot extends BaseBot {
+    hidden = true;
+    constructor(ctx, config) {
+        super(ctx, config, "qqguild");
+        this.platform = "qqguild";
+        this.selfId = config.profile.tiny_id;
+        this.parent = config.parent;
+        this.internal = config.parent.internal;
+        this.user.name = config.profile.nickname;
+        this.user.avatar = config.profile.avatar_url;
+        this.parent.guildBot = this;
+    }
+    get status() {
+        return this.parent.status;
+    }
+    set status(status) {
+        this.parent.status = status;
+    }
+    async start() {
+        await this.context.parallel("bot-connect", this);
+    }
+    async stop() {
+        // Don't stop this bot twice
+        if (!this.parent)
+            return;
+        // prevent circular reference and use this as already disposed
+        this.parent = undefined;
+        await this.context.parallel("bot-disconnect", this);
+    }
+    async getChannel(channelId, guildId) {
+        const { data } = await this.getChannelList(guildId);
+        return data.find((channel) => channel.id === channelId);
+    }
+    async getChannelList(guildId) {
+        const data = await this.internal.getGuildChannelList(guildId, false);
+        return { data: (data || []).map(OneBot.adaptChannel) };
+    }
+    async getGuild(guildId) {
+        const data = await this.internal.getGuildMetaByGuest(guildId);
+        return OneBot.adaptGuild(data);
+    }
+    async getGuildList() {
+        const data = await this.internal.getGuildList();
+        return { data: data.map(OneBot.adaptGuild) };
+    }
+    async getGuildMember(guildId, userId) {
+        const profile = await this.internal.getGuildMemberProfile(guildId, userId);
+        return OneBot.adaptQQGuildMemberProfile(profile);
+    }
+    async getGuildMemberList(guildId) {
+        let nextToken;
+        let list = [];
+        while (true) {
+            const data = await this.internal.getGuildMemberList(guildId, nextToken);
+            if (!data.members?.length)
+                break;
+            list = list.concat(data.members.map(OneBot.adaptQQGuildMemberInfo));
+            if (data.finished)
+                break;
+            nextToken = data.next_token;
+        }
+        return { data: list };
+    }
+}

package/lib/http.d.ts

@@ -0,0 +1,17 @@
+import { Adapter, Context, HTTP, Schema } from "koishi";
+import { OneBotBot } from "./bot";
+export declare class HttpServer<C extends Context = Context> extends Adapter<C, OneBotBot<C>> {
+    static inject: string[];
+    bots: OneBotBot<C>[];
+    fork(ctx: C, bot: OneBotBot<C, OneBotBot.Config & HttpServer.Options>): Promise<void>;
+    connect(bot: OneBotBot<C, OneBotBot.Config & HttpServer.Options>): Promise<void>;
+    disconnect(bot: OneBotBot<C>): Promise<void>;
+}
+export declare namespace HttpServer {
+    interface Options extends HTTP.Config {
+        protocol: "http";
+        path?: string;
+        secret?: string;
+    }
+    const Options: Schema<Options>;
+}

package/lib/http.js

@@ -0,0 +1,61 @@
+import { createHmac } from "crypto";
+import { Adapter, HTTP, Schema } from "koishi";
+import { dispatchSession } from "./utils";
+export class HttpServer extends Adapter {
+    static inject = ["server"];
+    async fork(ctx, bot) {
+        super.fork(ctx, bot);
+        const config = bot.config;
+        const { endpoint, token } = config;
+        if (!endpoint)
+            return;
+        const http = ctx.http.extend({
+            ...config,
+            headers: {
+                Authorization: `Token ${token}`
+            }
+        });
+        bot.internal._request = async (action, params) => {
+            return http.post("/" + action, params);
+        };
+        return bot.initialize();
+    }
+    async connect(bot) {
+        const { secret, path = "/onebot" } = bot.config;
+        this.ctx.server.post(path, (ctx) => {
+            if (secret) {
+                // no signature
+                const signature = ctx.headers["x-signature"];
+                if (!signature)
+                    return (ctx.status = 401);
+                // invalid signature
+                const sig = createHmac("sha1", secret)
+                    .update(ctx.request.response.body[Symbol.for("unparsedBody")])
+                    .digest("hex");
+                if (signature !== `sha1=${sig}`)
+                    return (ctx.status = 403);
+            }
+            const selfId = ctx.headers["x-self-id"].toString();
+            const bot = this.bots.find((bot) => bot.selfId === selfId);
+            if (!bot)
+                return (ctx.status = 403);
+            bot.logger.debug("[receive] %o", ctx.request.response.body);
+            dispatchSession(bot, ctx.request.response.body);
+        });
+    }
+    async disconnect(bot) {
+        bot.status = 4 /* Universal.Status.RECONNECT */;
+    }
+}
+(function (HttpServer) {
+    HttpServer.Options = Schema.intersect([
+        Schema.object({
+            protocol: Schema.const("http").required(),
+            path: Schema.string().description("服务器监听的路径。").default("/onebot"),
+            secret: Schema.string()
+                .description("接收事件推送时用于验证的字段，应该与 OneBot 的 secret 配置保持一致。")
+                .role("secret")
+        }).description("连接设置"),
+        HTTP.createConfig(true)
+    ]);
+})(HttpServer || (HttpServer = {}));

package/lib/index.d.ts

@@ -0,0 +1,21 @@
+import { Session } from "koishi";
+import { OneBotBot } from "./bot";
+import * as OneBot from "./utils";
+export { OneBot };
+export * from "./bot";
+export * from "./http";
+export * from "./ws";
+export default OneBotBot;
+declare module "@satorijs/core" {
+    interface Session {
+        onebot?: OneBot.Payload & OneBot.Internal;
+    }
+}
+declare module "koishi" {
+    interface Events {
+        "onebot/message-reactions-updated"(session: Session): void;
+        "onebot/channel-updated"(session: Session): void;
+        "onebot/channel-created"(session: Session): void;
+        "onebot/channel-destroyed"(session: Session): void;
+    }
+}

package/lib/index.js

@@ -0,0 +1,7 @@
+import { OneBotBot } from "./bot";
+import * as OneBot from "./utils";
+export { OneBot };
+export * from "./bot";
+export * from "./http";
+export * from "./ws";
+export default OneBotBot;

package/lib/types.d.ts

@@ -0,0 +1,474 @@
+import { Dict } from "koishi";
+import { BaseBot, CQCode } from "./bot";
+export interface Response {
+    status: string;
+    retcode: number;
+    data: any;
+    echo?: number;
+}
+export interface MessageId {
+    message_id: number;
+}
+export interface AccountInfo {
+    user_id: number;
+    tiny_id?: string;
+    nickname: string;
+}
+export interface QidianAccountInfo {
+    master_id: number;
+    ext_name: string;
+    create_time: number;
+}
+export interface StrangerInfo extends AccountInfo {
+    sex: "male" | "female" | "unknown";
+    age: number;
+}
+export interface TalkativeMemberInfo extends AccountInfo {
+    avatar: string;
+    day_count: number;
+}
+export type GroupRole = "member" | "admin" | "owner";
+export type HonorType = "talkative" | "performer" | "legend" | "strong_newbie" | "emotion";
+export interface HonoredMemberInfo {
+    avatar: string;
+    description: string;
+}
+export interface HonorInfo {
+    current_talkative: TalkativeMemberInfo;
+    talkative_list: HonoredMemberInfo[];
+    performer_list: HonoredMemberInfo[];
+    legend_list: HonoredMemberInfo[];
+    strong_newbie_list: HonoredMemberInfo[];
+    emotion_list: HonoredMemberInfo[];
+}
+export interface SenderInfo extends StrangerInfo {
+    area?: string;
+    level?: string;
+    title?: string;
+    role?: GroupRole;
+    card?: string;
+}
+export interface Message extends MessageId {
+    real_id?: number;
+    time: number;
+    message_seq: number;
+    message_type: "private" | "group" | "guild";
+    sender: SenderInfo;
+    group_id?: number;
+    guild_id?: string;
+    channel_id?: string;
+    message: string | CQCode[];
+    anonymous?: AnonymousInfo;
+}
+export interface AnonymousInfo {
+    id: number;
+    name: string;
+    flag: string;
+}
+export type RecordFormat = "mp3" | "amr" | "wma" | "m4a" | "spx" | "ogg" | "wav" | "flac";
+export type DataDirectory = "image" | "record" | "show" | "bface";
+export interface FriendInfo extends AccountInfo {
+    remark: string;
+}
+export interface UnidirectionalFriendInfo extends AccountInfo {
+    source: string;
+}
+export interface GroupBase {
+    group_id: number;
+    group_name: string;
+}
+export interface GroupInfo extends GroupBase {
+    member_count: number;
+    max_member_count: number;
+}
+export interface GroupMemberInfo extends SenderInfo {
+    card_changeable: boolean;
+    group_id: number;
+    join_time: number;
+    last_sent_time: number;
+    title_expire_time: number;
+    unfriendly: boolean;
+}
+export interface Credentials {
+    cookies: string;
+    csrf_token: number;
+}
+export interface ImageInfo {
+    file: string;
+}
+export interface RecordInfo {
+    file: string;
+}
+export interface VersionInfo {
+    app_name?: string;
+    app_version?: string;
+    app_full_name?: string;
+    protocol_version?: string;
+    coolq_edition?: "air" | "pro";
+    coolq_directory?: string;
+    plugin_version?: string;
+    plugin_build_number?: number;
+    plugin_build_configuration?: "debug" | "release";
+    version?: string;
+    go_cqhttp?: boolean;
+    runtime_version?: string;
+    runtime_os?: string;
+    protocol?: string;
+}
+export interface ImageInfo {
+    size?: number;
+    filename?: string;
+    url?: string;
+}
+export interface ForwardMessage {
+    sender: AccountInfo;
+    time: number;
+    content: string;
+}
+export interface EssenceMessage extends MessageId {
+    sender_id: number;
+    sender_nick: string;
+    sender_time: number;
+    operator_id: number;
+    operator_nick: string;
+    operator_time: number;
+}
+export interface VipInfo extends AccountInfo {
+    level: number;
+    level_speed: number;
+    vip_level: number;
+    vip_growth_speed: number;
+    vip_growth_total: string;
+}
+export interface GroupNotice {
+    notice_id: string;
+    sender_id: number;
+    publish_time: number;
+    message: {
+        text: string;
+        images: GroupNoticeImage[];
+    };
+}
+export interface GroupNoticeImage {
+    height: string;
+    width: string;
+    id: string;
+}
+export interface Statistics {
+    packet_received: number;
+    packet_sent: number;
+    packet_lost: number;
+    message_received: number;
+    message_sent: number;
+    disconnect_times: number;
+    lost_times: number;
+}
+export interface StatusInfo {
+    app_initialized: boolean;
+    app_enabled: boolean;
+    plugins_good: boolean;
+    app_good: boolean;
+    online: boolean;
+    good: boolean;
+    stat: Statistics;
+}
+export interface TextDetection {
+    text: string;
+    confidence: string;
+    coordinates: any;
+}
+export interface OcrResult {
+    language: string;
+    texts: TextDetection[];
+}
+export interface GroupRequest extends GroupBase {
+    request_id: number;
+    invitor_uin: number;
+    invitor_nick: string;
+    checked: boolean;
+    actor: number;
+}
+export interface InvitedRequest extends GroupRequest {
+}
+export interface JoinRequest extends GroupRequest {
+    message: string;
+}
+export interface GroupSystemMessageInfo {
+    invited_qequests: InvitedRequest[];
+    join_requests: JoinRequest[];
+}
+export interface GroupFileSystemInfo {
+    file_count: number;
+    limit_count: number;
+    used_space: number;
+    total_space: number;
+}
+export interface GroupFile {
+    file_id: string;
+    file_name: string;
+    busid: number;
+    file_size: number;
+    upload_time: number;
+    dead_time: number;
+    modify_time: number;
+    download_time: number;
+    uploader: number;
+    uploader_name: string;
+}
+export interface GroupFolder {
+    folder_id: string;
+    folder_name: string;
+    create_time: number;
+    creator: number;
+    creator_name: string;
+    total_file_count: number;
+}
+export interface GroupFileList {
+    files: GroupFile[];
+    folders: GroupFolder[];
+}
+export interface AtAllRemain {
+    can_at_all: boolean;
+    remain_at_all_count_for_group: number;
+    remain_at_all_count_for_uin: number;
+}
+export interface Device {
+    app_id: number;
+    device_name: string;
+    device_kind: string;
+}
+export interface ModelVariant {
+    model_show: string;
+    need_pay: boolean;
+}
+export declare enum SafetyLevel {
+    safe = 0,
+    unknown = 1,
+    danger = 2
+}
+export interface GuildServiceProfile {
+    nickname: string;
+    tiny_id: string;
+    avatar_url: string;
+}
+export interface GuildBaseInfo {
+    guild_id: string;
+    guild_name: string;
+}
+export interface GuildInfo extends GuildBaseInfo {
+    guild_display_id: string;
+}
+export interface GuildMeta extends GuildBaseInfo {
+    guild_profile: string;
+    create_time: number;
+    max_member_count: number;
+    max_robot_count: number;
+    max_admin_count: number;
+    member_count: number;
+    owner_id: string;
+}
+export interface ChannelInfo {
+    owner_guild_id: string;
+    channel_id: string;
+    channel_type: number;
+    channel_name: string;
+    create_time: number;
+    creator_id: string;
+    creator_tiny_id: string;
+    talk_permission: number;
+    visible_type: number;
+    current_slow_mode: number;
+    slow_modes: SlowModeInfo[];
+}
+export interface SlowModeInfo {
+    slow_mode_key: number;
+    slow_mode_text: string;
+    speak_frequency: number;
+    slow_mode_circle: number;
+}
+export interface GuildMemberListData {
+    members: GuildMemberInfo[];
+    finished: boolean;
+    next_token: string;
+}
+export interface GuildMemberRole {
+    role_id: string;
+    role_name: string;
+}
+export interface GuildMemberInfo extends GuildMemberRole {
+    tiny_id: string;
+    title: string;
+    nickname: string;
+    role: number;
+}
+export interface GuildMemberProfile {
+    tiny_id: string;
+    nickname: string;
+    avatar_url: string;
+    join_time: number;
+    roles: GuildMemberRole[];
+}
+export interface ReactionInfo {
+    emoji_id: string;
+    emoji_index: number;
+    emoji_type: number;
+    emoji_name: string;
+    count: number;
+    clicked: boolean;
+}
+export interface Payload extends Message {
+    time: number;
+    self_id: number;
+    self_tiny_id?: string;
+    post_type: string;
+    request_type: string;
+    notice_type: string;
+    meta_event_type: string;
+    honor_type: string;
+    sub_type: string;
+    message_id: number;
+    user_id: number;
+    target_id: number;
+    operator_id: number;
+    raw_message: string;
+    font: number;
+    comment: string;
+    flag: string;
+    old_info: ChannelInfo;
+    new_info: ChannelInfo;
+    channel_info: ChannelInfo;
+    current_reactions: ReactionInfo[];
+    file: File;
+}
+export interface File {
+    name: string;
+    size: number;
+    url: string;
+}
+type id = string | number;
+export declare class TimeoutError extends Error {
+    constructor(args: Dict, url: string);
+}
+export declare class Internal {
+    readonly bot: BaseBot;
+    _request?(action: string, params: Dict): Promise<Response>;
+    constructor(bot: BaseBot);
+    private _get;
+    setGroupAnonymousBan(group_id: string, meta: string | object, duration?: number): Promise<void>;
+    setGroupAnonymousBanAsync(group_id: string, meta: string | object, duration?: number): Promise<void>;
+    sendPrivateMsg(user_id: id, message: string | readonly CQCode[], auto_escape?: boolean): Promise<number>;
+    sendPrivateMsgAsync(user_id: id, message: string | readonly CQCode[], auto_escape?: boolean): Promise<void>;
+    sendGroupMsg(group_id: id, message: string | readonly CQCode[], auto_escape?: boolean): Promise<number>;
+    sendGroupMsgAsync(group_id: id, message: string | readonly CQCode[], auto_escape?: boolean): Promise<void>;
+    sendGroupForwardMsg(group_id: id, messages: readonly CQCode[]): Promise<number>;
+    sendGroupForwardMsgAsync(group_id: id, messages: readonly CQCode[]): Promise<void>;
+    sendPrivateForwardMsg(user_id: id, messages: readonly CQCode[]): Promise<number>;
+    sendPrivateForwardMsgAsync(user_id: id, messages: readonly CQCode[]): Promise<void>;
+    deleteMsg(message_id: id): Promise<void>;
+    deleteMsgAsync(message_id: id): Promise<void>;
+    setEssenceMsg(message_id: id): Promise<void>;
+    setEssenceMsgAsync(message_id: id): Promise<void>;
+    deleteEssenceMsg(message_id: id): Promise<void>;
+    deleteEssenceMsgAsync(message_id: id): Promise<void>;
+    markMsgAsRead(message_id: id): Promise<void>;
+    sendLike(user_id: id, times?: number): Promise<void>;
+    sendLikeAsync(user_id: id, times?: number): Promise<void>;
+    sendGroupSign(group_id: id): Promise<void>;
+    sendGroupSignAsync(group_id: id): Promise<void>;
+    getMsg(message_id: id): Promise<Message>;
+    getForwardMsg(message_id: id): Promise<ForwardMessage[]>;
+    getEssenceMsgList(group_id: id): Promise<EssenceMessage[]>;
+    getWordSlices(content: string): Promise<string[]>;
+    ocrImage(image: string): Promise<OcrResult>;
+    getGroupMsgHistory(group_id: id, message_seq?: number): Promise<{
+        messages: Message[];
+    }>;
+    deleteFriend(user_id: id): Promise<void>;
+    deleteFriendAsync(user_id: id): Promise<void>;
+    deleteUnidirectionalFriend(user_id: id): Promise<void>;
+    deleteUnidirectionalFriendAsync(user_id: id): Promise<void>;
+    setFriendAddRequest(flag: string, approve: boolean, remark?: string): Promise<void>;
+    setFriendAddRequestAsync(flag: string, approve: boolean, remark?: string): Promise<void>;
+    setGroupAddRequest(flag: string, subType: "add" | "invite", approve: boolean, reason?: string): Promise<void>;
+    setGroupAddRequestAsync(flag: string, subType: "add" | "invite", approve: boolean, reason?: string): Promise<void>;
+    setGroupKick(group_id: id, user_id: id, reject_add_request?: boolean): Promise<void>;
+    setGroupKickAsync(group_id: id, user_id: id, reject_add_request?: boolean): Promise<void>;
+    setGroupBan(group_id: id, user_id: id, duration?: number): Promise<void>;
+    setGroupBanAsync(group_id: id, user_id: id, duration?: number): Promise<void>;
+    setGroupWholeBan(group_id: id, enable?: boolean): Promise<void>;
+    setGroupWholeBanAsync(group_id: id, enable?: boolean): Promise<void>;
+    setGroupAdmin(group_id: id, user_id: id, enable?: boolean): Promise<void>;
+    setGroupAdminAsync(group_id: id, user_id: id, enable?: boolean): Promise<void>;
+    setGroupAnonymous(group_id: id, enable?: boolean): Promise<void>;
+    setGroupAnonymousAsync(group_id: id, enable?: boolean): Promise<void>;
+    setGroupCard(group_id: id, user_id: id, card?: string): Promise<void>;
+    setGroupCardAsync(group_id: id, user_id: id, card?: string): Promise<void>;
+    setGroupLeave(group_id: id, is_dismiss?: boolean): Promise<void>;
+    setGroupLeaveAsync(group_id: id, is_dismiss?: boolean): Promise<void>;
+    setGroupSpecialTitle(group_id: id, user_id: id, special_title?: string, duration?: number): Promise<void>;
+    setGroupSpecialTitleAsync(group_id: id, user_id: id, special_title?: string, duration?: number): Promise<void>;
+    setGroupName(group_id: id, name: string): Promise<void>;
+    setGroupNameAsync(group_id: id, name: string): Promise<void>;
+    setGroupPortrait(group_id: id, file: string, cache?: boolean): Promise<void>;
+    setGroupPortraitAsync(group_id: id, file: string, cache?: boolean): Promise<void>;
+    getGroupAtAllRemain(group_id: id): Promise<AtAllRemain>;
+    sendGroupNotice(group_id: id, content: string, image?: string, pinned?: id, confirm_required?: id): Promise<void>;
+    sendGroupNoticeAsync(group_id: id, content: string, image?: string, pinned?: id, confirm_required?: id): Promise<void>;
+    getGroupNotice(group_id: id): Promise<GroupNotice[]>;
+    delGroupNotice(group_id: id, notice_id: id): Promise<void>;
+    getLoginInfo(): Promise<AccountInfo>;
+    qidianGetLoginInfo(): Promise<QidianAccountInfo>;
+    setQqProfile(nickname: string, company: string, email: string, college: string, personal_note: string): Promise<void>;
+    setQqProfileAsync(nickname: string, company: string, email: string, college: string, personal_note: string): Promise<void>;
+    setQqAvatar(file: string): Promise<void>;
+    setOnlineStatus(status: string, extStatus: string, batteryStatus: string): Promise<void>;
+    getVipInfo(): Promise<VipInfo>;
+    getStrangerInfo(user_id: id, no_cache?: boolean): Promise<StrangerInfo>;
+    getFriendList(): Promise<FriendInfo[]>;
+    getUnidirectionalFriendList(): Promise<UnidirectionalFriendInfo[]>;
+    getGroupInfo(group_id: id, no_cache?: boolean): Promise<GroupInfo>;
+    getGroupList(no_cache?: boolean): Promise<GroupInfo[]>;
+    getGroupMemberInfo(group_id: id, user_id: id, no_cache?: boolean): Promise<GroupMemberInfo>;
+    getGroupMemberList(group_id: id, no_cache?: boolean): Promise<GroupMemberInfo[]>;
+    getGroupHonorInfo(group_id: id, type: HonorType): Promise<HonorInfo>;
+    getGroupSystemMsg(): Promise<GroupSystemMessageInfo>;
+    getGroupFileSystemInfo(group_id: id): Promise<GroupFileSystemInfo>;
+    getGroupRootFiles(group_id: id): Promise<GroupFileList>;
+    getGroupFilesByFolder(group_id: id, folder_id: string): Promise<GroupFileList>;
+    getGroupFileUrl(group_id: id, file_id: string, busid: number): Promise<string>;
+    downloadFile(url: string, headers?: string | readonly string[], thread_count?: number): Promise<string>;
+    uploadPrivateFile(user_id: id, file: string, name: string): Promise<void>;
+    uploadGroupFile(group_id: id, file: string, name: string, folder?: string): Promise<void>;
+    createGroupFileFolder(group_id: id, folder_id: string, name: string): Promise<void>;
+    deleteGroupFolder(group_id: id, folder_id: string): Promise<void>;
+    deleteGroupFile(group_id: id, folder_id: string, file_id: string, busid: number): Promise<void>;
+    getOnlineClients(no_cache?: boolean): Promise<Device[]>;
+    checkUrlSafely(url: string): Promise<SafetyLevel>;
+    getModelShow(model: string): Promise<ModelVariant[]>;
+    setModelShow(model: string, model_show: string): Promise<void>;
+    getCookies(domain?: string): Promise<string>;
+    getCsrfToken(): Promise<number>;
+    getCredentials(domain?: string): Promise<Credentials>;
+    getRecord(file: string, out_format: RecordFormat, full_path?: boolean): Promise<RecordInfo>;
+    getImage(file: string): Promise<ImageInfo>;
+    canSendImage(): Promise<boolean>;
+    canSendRecord(): Promise<boolean>;
+    getStatus(): Promise<StatusInfo>;
+    getVersionInfo(): Promise<VersionInfo>;
+    setRestart(delay?: number): Promise<void>;
+    reloadEventFilter(): Promise<void>;
+    cleanCache(): Promise<void>;
+    getGuildServiceProfile(): Promise<GuildServiceProfile>;
+    getGuildList(): Promise<GuildInfo[]>;
+    getGuildMetaByGuest(guild_id: id): Promise<GuildMeta>;
+    getGuildChannelList(guild_id: id, no_cache: boolean): Promise<ChannelInfo[]>;
+    getGuildMemberList(guild_id: id, next_token?: string): Promise<GuildMemberListData>;
+    getGuildMemberProfile(guild_id: id, user_id: id): Promise<GuildMemberProfile>;
+    sendGuildChannelMsg(guild_id: id, channel_id: id, message: string | readonly CQCode[]): Promise<number>;
+    uploadImage(file: string): Promise<string>;
+    getPrivateFileUrl(user_id: id, file_id: string, file_hash?: string): Promise<string>;
+    moveGroupFile(group_id: id, file_id: string, parent_directory: string, target_directory: string): Promise<void>;
+    deleteGroupFileFolder(group_id: id, folder_id: string): Promise<void>;
+    renameGroupFileFolder(group_id: id, folder_id: string, new_folder_name: string): Promise<void>;
+}
+export {};