kook-sdk 1.0.0

package/dist/client/http-client.js

@@ -0,0 +1,919 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const types_1 = require("../types");
+// KOOK API 基础 URL
+const API_BASE_URL = 'https://www.kookapp.cn/api/v3';
+class HttpClient {
+    constructor(token) {
+        this.axios = axios_1.default.create({
+            baseURL: API_BASE_URL,
+            headers: {
+                Authorization: `Bot ${token}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 30000,
+        });
+        // 响应拦截器
+        this.axios.interceptors.response.use((response) => response, (error) => {
+            if (error.response?.data) {
+                const { code, message } = error.response.data;
+                throw new types_1.KookAPIError(code, message, error.response.data);
+            }
+            throw error;
+        });
+    }
+    // 通用请求方法
+    async request(config) {
+        const response = await this.axios.request(config);
+        if (response.data.code !== 0) {
+            throw new types_1.KookAPIError(response.data.code, response.data.message, response.data);
+        }
+        return response.data.data;
+    }
+    // GET 请求
+    async get(url, params) {
+        return this.request({ method: 'GET', url, params });
+    }
+    // POST 请求
+    async post(url, data) {
+        return this.request({ method: 'POST', url, data });
+    }
+    // ========== 用户相关接口 ==========
+    // 获取当前用户信息
+    async getCurrentUser() {
+        return this.get('/user/me');
+    }
+    // 获取用户详情
+    async getUser(userId) {
+        return this.get('/user/view', { user_id: userId });
+    }
+    // 下线当前用户
+    async offline() {
+        await this.post('/user/offline');
+    }
+    // ========== 服务器相关接口 ==========
+    // 获取服务器列表
+    async getGuilds() {
+        const result = await this.get('/guild/list');
+        return result.items;
+    }
+    // 获取服务器详情
+    async getGuild(guildId) {
+        return this.get('/guild/view', { guild_id: guildId });
+    }
+    // 获取服务器中的用户列表
+    async getGuildUsers(guildId, options) {
+        return this.get('/guild/user-list', {
+            guild_id: guildId,
+            ...options,
+        });
+    }
+    // 修改服务器中用户的昵称
+    async setGuildUserNickname(guildId, userId, nickname) {
+        await this.post('/guild/nickname', {
+            guild_id: guildId,
+            user_id: userId,
+            nickname,
+        });
+    }
+    // 离开服务器
+    async leaveGuild(guildId) {
+        await this.post('/guild/leave', { guild_id: guildId });
+    }
+    // 踢出服务器用户
+    async kickGuildUser(guildId, targetId) {
+        await this.post('/guild/kickout', {
+            guild_id: guildId,
+            target_id: targetId,
+        });
+    }
+    // ========== 频道相关接口 ==========
+    // 获取频道列表
+    async getChannels(guildId) {
+        const result = await this.get('/channel/list', {
+            guild_id: guildId,
+        });
+        return result.items;
+    }
+    // 获取频道详情
+    async getChannel(channelId) {
+        return this.get('/channel/view', { target_id: channelId });
+    }
+    // 创建频道
+    async createChannel(guildId, name, options) {
+        return this.post('/channel/create', {
+            guild_id: guildId,
+            name,
+            ...options,
+        });
+    }
+    // 修改频道
+    async updateChannel(channelId, options) {
+        return this.post('/channel/update', {
+            channel_id: channelId,
+            ...options,
+        });
+    }
+    // 删除频道
+    async deleteChannel(channelId) {
+        await this.post('/channel/delete', { channel_id: channelId });
+    }
+    // 获取频道用户列表
+    async getChannelUsers(channelId) {
+        const result = await this.get('/channel/user-list', {
+            target_id: channelId,
+        });
+        return result.items;
+    }
+    // 移动频道
+    async moveChannel(channelId, parentId, after) {
+        await this.post('/channel/move-user', {
+            channel_id: channelId,
+            parent_id: parentId,
+            after,
+        });
+    }
+    // ========== 消息相关接口 ==========
+    // 获取频道消息列表
+    async getMessages(channelId, options) {
+        return this.get('/message/list', {
+            target_id: channelId,
+            ...options,
+        });
+    }
+    // 获取消息详情
+    async getMessage(msgId) {
+        return this.get('/message/view', { msg_id: msgId });
+    }
+    // 发送频道消息
+    async sendChannelMessage(channelId, content, options) {
+        return this.post('/message/create', {
+            target_id: channelId,
+            content,
+            ...options,
+        });
+    }
+    // 更新频道消息
+    async updateMessage(msgId, content, options) {
+        return this.post('/message/update', {
+            msg_id: msgId,
+            content,
+            ...options,
+        });
+    }
+    // 删除频道消息
+    async deleteMessage(msgId) {
+        await this.post('/message/delete', { msg_id: msgId });
+    }
+    // 获取频道消息反应列表
+    async getMessageReactions(msgId, emoji) {
+        return this.get('/message/reaction-list', {
+            msg_id: msgId,
+            emoji,
+        });
+    }
+    // 添加消息反应
+    async addMessageReaction(msgId, emoji) {
+        await this.post('/message/add-reaction', {
+            msg_id: msgId,
+            emoji,
+        });
+    }
+    // 删除消息反应
+    async removeMessageReaction(msgId, emoji, userId) {
+        await this.post('/message/delete-reaction', {
+            msg_id: msgId,
+            emoji,
+            user_id: userId,
+        });
+    }
+    // ========== 私聊相关接口 ==========
+    // 获取私信会话列表
+    async getDirectMessageSessions() {
+        const result = await this.get('/direct-message/list');
+        return result.items;
+    }
+    // 创建私信会话
+    async createDirectMessageSession(targetId) {
+        return this.post('/direct-message/create', { target_id: targetId });
+    }
+    // 发送私信消息
+    async sendDirectMessage(targetId, content, options) {
+        return this.post('/direct-message/create', {
+            target_id: targetId,
+            content,
+            ...options,
+        });
+    }
+    // ========== 角色相关接口 ==========
+    // 获取服务器角色列表
+    async getGuildRoles(guildId) {
+        const result = await this.get('/guild-role/list', { guild_id: guildId });
+        return result.items;
+    }
+    // 创建角色
+    async createRole(guildId, name, options) {
+        return this.post('/guild-role/create', {
+            guild_id: guildId,
+            name,
+            ...options,
+        });
+    }
+    // 更新角色
+    async updateRole(guildId, roleId, options) {
+        return this.post('/guild-role/update', {
+            guild_id: guildId,
+            role_id: roleId,
+            ...options,
+        });
+    }
+    // 删除角色
+    async deleteRole(guildId, roleId) {
+        await this.post('/guild-role/delete', {
+            guild_id: guildId,
+            role_id: roleId,
+        });
+    }
+    // 赋予用户角色
+    async grantRole(guildId, userId, roleId) {
+        await this.post('/guild-role/grant', {
+            guild_id: guildId,
+            user_id: userId,
+            role_id: roleId,
+        });
+    }
+    // 撤销用户角色
+    async revokeRole(guildId, userId, roleId) {
+        await this.post('/guild-role/revoke', {
+            guild_id: guildId,
+            user_id: userId,
+            role_id: roleId,
+        });
+    }
+    // ========== 资源上传接口 ==========
+    // 上传文件/图片/视频
+    // 支持 Buffer、Stream 或文件路径
+    async uploadAsset(file, options) {
+        const formData = new form_data_1.default();
+        if (typeof file === 'string') {
+            // 文件路径
+            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const fileStream = fs.createReadStream(file);
+            const filename = options?.filename || path.basename(file);
+            formData.append('file', fileStream, {
+                filename,
+                contentType: options?.contentType,
+            });
+        }
+        else {
+            // Buffer 或 Stream
+            formData.append('file', file, {
+                filename: options?.filename || 'file',
+                contentType: options?.contentType,
+            });
+        }
+        const response = await this.axios.post('/asset/create', formData, {
+            headers: {
+                ...formData.getHeaders(),
+            },
+        });
+        if (response.data.code !== 0) {
+            throw new types_1.KookAPIError(response.data.code, response.data.message, response.data);
+        }
+        return response.data.data;
+    }
+    // ========== 消息置顶接口 ==========
+    // 置顶频道消息
+    async pinMessage(msgId) {
+        await this.post('/message/pin', { msg_id: msgId });
+    }
+    // 取消置顶频道消息
+    async unpinMessage(msgId) {
+        await this.post('/message/unpin', { msg_id: msgId });
+    }
+    // ========== 语音接口 ==========
+    // 加入语音频道
+    async joinVoiceChannel(channelId, options) {
+        return this.post('/voice/join', {
+            channel_id: channelId,
+            ...options,
+        });
+    }
+    // 离开语音频道
+    async leaveVoiceChannel(channelId) {
+        await this.post('/voice/leave', { channel_id: channelId });
+    }
+    // 获取机器人加入的语音频道列表
+    async getVoiceChannels() {
+        return this.get('/voice/list');
+    }
+    // 保持语音连接活跃
+    async keepVoiceAlive(channelId) {
+        await this.post('/voice/keep-alive', { channel_id: channelId });
+    }
+    // ========== 邀请相关接口 ==========
+    // 获取邀请列表
+    async getInvites(guildId) {
+        const result = await this.get('/invite/list', {
+            guild_id: guildId,
+        });
+        return result.items;
+    }
+    // 创建邀请链接
+    async createInvite(channelId, options) {
+        return this.post('/invite/create', {
+            channel_id: channelId,
+            ...options,
+        });
+    }
+    // 删除邀请链接
+    async deleteInvite(urlCode, guildId) {
+        await this.post('/invite/delete', {
+            url_code: urlCode,
+            guild_id: guildId,
+        });
+    }
+    // ========== 服务器黑名单相关接口 ==========
+    // 获取黑名单列表
+    async getBlacklist(guildId, options) {
+        return this.get('/blacklist/list', {
+            guild_id: guildId,
+            ...options,
+        });
+    }
+    // 添加黑名单
+    async addBlacklist(guildId, targetId, options) {
+        await this.post('/blacklist/create', {
+            guild_id: guildId,
+            target_id: targetId,
+            ...options,
+        });
+    }
+    // 移除黑名单
+    async removeBlacklist(guildId, targetId) {
+        await this.post('/blacklist/delete', {
+            guild_id: guildId,
+            target_id: targetId,
+        });
+    }
+    // ========== 服务器静音/闭麦相关接口 ==========
+    // 获取静音/闭麦列表
+    async getMuteList(guildId) {
+        const result = await this.get('/guild-mute/list', {
+            guild_id: guildId,
+        });
+        return result.items;
+    }
+    // 添加静音/闭麦
+    async addMute(guildId, targetId, type // 1: 麦克风静音, 2: 耳机静音
+    ) {
+        await this.post('/guild-mute/create', {
+            guild_id: guildId,
+            target_id: targetId,
+            type,
+        });
+    }
+    // 移除静音/闭麦
+    async removeMute(guildId, targetId, type) {
+        await this.post('/guild-mute/delete', {
+            guild_id: guildId,
+            target_id: targetId,
+            type,
+        });
+    }
+    // ========== 服务器助力相关接口 ==========
+    // 获取助力列表
+    async getBoosts(guildId) {
+        const result = await this.get('/guild-boost/list', {
+            guild_id: guildId,
+        });
+        return result.items;
+    }
+    // 获取助力历史
+    async getBoostHistory(guildId, options) {
+        return this.get('/guild-boost/history', {
+            guild_id: guildId,
+            ...options,
+        });
+    }
+    // ========== 服务器表情相关接口 ==========
+    // 获取服务器表情列表
+    async getGuildEmojis(guildId) {
+        const result = await this.get('/guild-emoji/list', {
+            guild_id: guildId,
+        });
+        return result.items;
+    }
+    // 创建服务器表情
+    async createGuildEmoji(guildId, name, emoji) {
+        return this.post('/guild-emoji/create', {
+            guild_id: guildId,
+            name,
+            emoji,
+        });
+    }
+    // 更新服务器表情
+    async updateGuildEmoji(guildId, emojiId, name) {
+        return this.post('/guild-emoji/update', {
+            guild_id: guildId,
+            id: emojiId,
+            name,
+        });
+    }
+    // 删除服务器表情
+    async deleteGuildEmoji(guildId, emojiId) {
+        await this.post('/guild-emoji/delete', {
+            guild_id: guildId,
+            emoji_id: emojiId,
+        });
+    }
+    // ========== 服务器公告相关接口 ==========
+    // 获取公告列表
+    async getAnnouncements(guildId, options) {
+        return this.get('/announcement/list', {
+            guild_id: guildId,
+            ...options,
+        });
+    }
+    // 创建公告
+    async createAnnouncement(guildId, channelId, content) {
+        return this.post('/announcement/create', {
+            guild_id: guildId,
+            channel_id: channelId,
+            content,
+        });
+    }
+    // 更新公告
+    async updateAnnouncement(announcementId, content) {
+        return this.post('/announcement/update', {
+            id: announcementId,
+            content,
+        });
+    }
+    // 删除公告
+    async deleteAnnouncement(announcementId) {
+        await this.post('/announcement/delete', { id: announcementId });
+    }
+    // ========== 服务器积分相关接口 ==========
+    // 获取积分排行
+    async getIntimacyRank(guildId, options) {
+        return this.get('/intimacy/rank', {
+            guild_id: guildId,
+            ...options,
+        });
+    }
+    // 获取用户积分信息
+    async getIntimacyInfo(userId, guildId) {
+        return this.get('/intimacy/index', {
+            user_id: userId,
+            guild_id: guildId,
+        });
+    }
+    // 更新用户积分
+    async updateIntimacy(userId, guildId, score) {
+        await this.post('/intimacy/update', {
+            user_id: userId,
+            guild_id: guildId,
+            score,
+        });
+    }
+    // ========== 游戏相关接口 ==========
+    // 获取游戏列表
+    async getGames() {
+        const result = await this.get('/game');
+        return result.items;
+    }
+    // 创建游戏
+    async createGame(name, icon, options) {
+        return this.post('/game/create', {
+            name,
+            icon,
+            ...options,
+        });
+    }
+    // 更新游戏
+    async updateGame(gameId, options) {
+        return this.post('/game/update', {
+            id: gameId,
+            ...options,
+        });
+    }
+    // 删除游戏
+    async deleteGame(gameId) {
+        await this.post('/game/delete', { id: gameId });
+    }
+    // 开始玩游戏
+    async startPlaying(gameId) {
+        await this.post('/game/activity', {
+            id: gameId,
+            data_type: 1,
+        });
+    }
+    // 结束玩游戏
+    async stopPlaying(gameId) {
+        await this.post('/game/delete-activity', { id: gameId });
+    }
+    // ========== 徽章相关接口 ==========
+    // 获取徽章列表
+    async getBadges(guildId) {
+        const result = await this.get('/badge/list', {
+            guild_id: guildId,
+        });
+        return result.items;
+    }
+    // 创建徽章
+    async createBadge(guildId, name, icon, options) {
+        return this.post('/badge/create', {
+            guild_id: guildId,
+            name,
+            icon,
+            ...options,
+        });
+    }
+    // 更新徽章
+    async updateBadge(badgeId, options) {
+        return this.post('/badge/update', {
+            id: badgeId,
+            ...options,
+        });
+    }
+    // 删除徽章
+    async deleteBadge(badgeId) {
+        await this.post('/badge/delete', { id: badgeId });
+    }
+    // 授予用户徽章
+    async grantBadge(guildId, userId, badgeId) {
+        await this.post('/badge/grant', {
+            guild_id: guildId,
+            user_id: userId,
+            badge_id: badgeId,
+        });
+    }
+    // 撤销用户徽章
+    async revokeBadge(guildId, userId, badgeId) {
+        await this.post('/badge/revoke', {
+            guild_id: guildId,
+            user_id: userId,
+            badge_id: badgeId,
+        });
+    }
+    // ========== 服务器日程相关接口 ==========
+    // 获取日程列表
+    async getSchedules(channelId, options) {
+        return this.get('/schedule/list', {
+            channel_id: channelId,
+            ...options,
+        });
+    }
+    // 获取日程详情
+    async getSchedule(scheduleId) {
+        return this.get('/schedule/view', { id: scheduleId });
+    }
+    // 创建日程
+    async createSchedule(channelId, title, startTime, endTime, options) {
+        return this.post('/schedule/create', {
+            channel_id: channelId,
+            title,
+            start_time: startTime,
+            end_time: endTime,
+            ...options,
+        });
+    }
+    // 更新日程
+    async updateSchedule(scheduleId, options) {
+        return this.post('/schedule/update', {
+            id: scheduleId,
+            ...options,
+        });
+    }
+    // 删除日程
+    async deleteSchedule(scheduleId) {
+        await this.post('/schedule/delete', { id: scheduleId });
+    }
+    // ========== 频道分组相关接口 ==========
+    // 获取频道分组列表
+    async getChannelCategories(guildId) {
+        const result = await this.get('/channel/list', {
+            guild_id: guildId,
+        });
+        return result.items.filter((item) => item.is_category);
+    }
+    // 创建频道分组
+    async createChannelCategory(guildId, name) {
+        return this.post('/channel/create', {
+            guild_id: guildId,
+            name,
+            is_category: true,
+        });
+    }
+    // 更新频道分组
+    async updateChannelCategory(categoryId, name) {
+        return this.post('/channel/update', {
+            channel_id: categoryId,
+            name,
+        });
+    }
+    // 删除频道分组
+    async deleteChannelCategory(categoryId) {
+        await this.post('/channel/delete', { channel_id: categoryId });
+    }
+    // 移动频道到分组
+    async moveChannelToCategory(channelId, parentId) {
+        await this.post('/channel/move-user', {
+            channel_id: channelId,
+            parent_id: parentId,
+        });
+    }
+    // ========== 用户聊天相关接口 ==========
+    // 获取用户聊天会话列表
+    async getUserChats() {
+        const result = await this.get('/user-chat/list');
+        return result.items;
+    }
+    // 获取用户聊天会话详情
+    async getUserChat(chatId) {
+        return this.get('/user-chat/view', { chat_id: chatId });
+    }
+    // 创建用户聊天会话
+    async createUserChat(targetId) {
+        return this.post('/user-chat/create', { target_id: targetId });
+    }
+    // 删除用户聊天会话
+    async deleteUserChat(chatId) {
+        await this.post('/user-chat/delete', { chat_id: chatId });
+    }
+    // ========== 频道角色权限相关接口 ==========
+    // 获取频道角色权限列表
+    async getChannelRolePermissions(channelId) {
+        const result = await this.get('/channel-role/index', {
+            channel_id: channelId,
+        });
+        return result.items;
+    }
+    // 创建频道角色权限
+    async createChannelRolePermission(channelId, roleId, allow, deny) {
+        return this.post('/channel-role/create', {
+            channel_id: channelId,
+            role_id: roleId,
+            allow,
+            deny,
+        });
+    }
+    // 更新频道角色权限
+    async updateChannelRolePermission(channelId, roleId, allow, deny) {
+        return this.post('/channel-role/update', {
+            channel_id: channelId,
+            role_id: roleId,
+            allow,
+            deny,
+        });
+    }
+    // 删除频道角色权限
+    async deleteChannelRolePermission(channelId, roleId) {
+        await this.post('/channel-role/delete', {
+            channel_id: channelId,
+            role_id: roleId,
+        });
+    }
+    // ========== 频道用户权限相关接口 ==========
+    // 获取频道用户权限列表
+    async getChannelUserPermissions(channelId) {
+        const result = await this.get('/channel-user/index', {
+            channel_id: channelId,
+        });
+        return result.items;
+    }
+    // 创建频道用户权限
+    async createChannelUserPermission(channelId, userId, allow, deny) {
+        return this.post('/channel-user/create', {
+            channel_id: channelId,
+            user_id: userId,
+            allow,
+            deny,
+        });
+    }
+    // 更新频道用户权限
+    async updateChannelUserPermission(channelId, userId, allow, deny) {
+        return this.post('/channel-user/update', {
+            channel_id: channelId,
+            user_id: userId,
+            allow,
+            deny,
+        });
+    }
+    // 删除频道用户权限
+    async deleteChannelUserPermission(channelId, userId) {
+        await this.post('/channel-user/delete', {
+            channel_id: channelId,
+            user_id: userId,
+        });
+    }
+    // ========== 服务器打卡相关接口 ==========
+    // 获取服务器打卡信息
+    async getPunchIn(guildId) {
+        return this.get('/punch-in/index', { guild_id: guildId });
+    }
+    // 服务器打卡
+    async punchIn(guildId) {
+        await this.post('/punch-in/punch-in', { guild_id: guildId });
+    }
+    // ========== 批量相关接口 ==========
+    // 批量获取用户信息
+    async getUsersBatch(userIds) {
+        const result = await this.post('/user/batch-get-user-info', {
+            user_ids: userIds,
+        });
+        return result.items;
+    }
+    // 批量获取服务器信息
+    async getGuildsBatch(guildIds) {
+        const result = await this.post('/guild/batch-get-guild-info', {
+            guild_ids: guildIds,
+        });
+        return result.items;
+    }
+    // ========== 服务器设置相关接口 ==========
+    // 获取服务器设置
+    async getGuildSettings(guildId) {
+        return this.get('/guild-setting/index', { guild_id: guildId });
+    }
+    // ========== 网关相关接口 ==========
+    // 获取网关连接地址
+    async getGateway(compress) {
+        return this.get('/gateway/index', { compress });
+    }
+    // ========== 服务器欢迎设置相关接口 ==========
+    // 获取服务器欢迎设置
+    async getGuildWelcome(guildId) {
+        return this.get('/guild-welcome/index', { guild_id: guildId });
+    }
+    // 更新服务器欢迎设置
+    async updateGuildWelcome(guildId, options) {
+        return this.post('/guild-welcome/update', {
+            guild_id: guildId,
+            ...options,
+        });
+    }
+    // ========== 服务器通知设置相关接口 ==========
+    // 获取服务器通知设置
+    async getGuildNotify(guildId) {
+        return this.get('/guild-notify/index', { guild_id: guildId });
+    }
+    // 更新服务器通知设置
+    async updateGuildNotify(guildId, notifyType) {
+        return this.post('/guild-notify/update', {
+            guild_id: guildId,
+            notify_type: notifyType,
+        });
+    }
+    // ========== 私聊消息相关扩展接口 ==========
+    // 获取私聊消息详情
+    async getDirectMessageDetail(msgId) {
+        return this.get('/direct-message/view', { msg_id: msgId });
+    }
+    // 更新私聊消息
+    async updateDirectMessage(msgId, content, options) {
+        return this.post('/direct-message/update', {
+            msg_id: msgId,
+            content,
+            ...options,
+        });
+    }
+    // 删除私聊消息
+    async deleteDirectMessage(msgId) {
+        await this.post('/direct-message/delete', { msg_id: msgId });
+    }
+    // ========== 消息相关扩展接口 ==========
+    // 添加消息阅读回执
+    async addMessageReadReceipt(msgId) {
+        await this.post('/message/add-receipt', { msg_id: msgId });
+    }
+    // 获取消息阅读回执列表
+    async getMessageReadReceipts(msgId) {
+        return this.get('/message/receipt-list', { msg_id: msgId });
+    }
+    // ========== 频道相关扩展接口 ==========
+    // 设置频道语音质量
+    async setVoiceQuality(channelId, quality) {
+        await this.post('/channel/set-voice-quality', {
+            channel_id: channelId,
+            voice_quality: quality,
+        });
+    }
+    // 设置频道慢速模式
+    async setSlowMode(channelId, slowMode) {
+        await this.post('/channel/set-slow-mode', {
+            channel_id: channelId,
+            slow_mode: slowMode,
+        });
+    }
+    // ========== 服务器角色权限相关扩展接口 ==========
+    // 批量更新服务器角色权限
+    async batchUpdateGuildRolePermissions(guildId, permissions) {
+        await this.post('/guild-role/batch-update-permissions', {
+            guild_id: guildId,
+            permissions,
+        });
+    }
+    // ========== 用户相关扩展接口 ==========
+    // 获取用户好友列表
+    async getFriends() {
+        const result = await this.get('/friend/list');
+        return result.items;
+    }
+    // 获取好友申请列表
+    async getFriendRequests() {
+        return this.get('/friend/request-list');
+    }
+    // 发送好友申请
+    async sendFriendRequest(targetId, content) {
+        await this.post('/friend/request', {
+            target_id: targetId,
+            content,
+        });
+    }
+    // 接受好友申请
+    async acceptFriendRequest(targetId) {
+        await this.post('/friend/accept', { target_id: targetId });
+    }
+    // 拒绝好友申请
+    async declineFriendRequest(targetId) {
+        await this.post('/friend/decline', { target_id: targetId });
+    }
+    // 删除好友
+    async deleteFriend(targetId) {
+        await this.post('/friend/delete', { target_id: targetId });
+    }
+    // ========== 服务器成员相关扩展接口 ==========
+    // 获取服务器成员在线状态
+    async getGuildMemberOnlineStatus(guildId, userId) {
+        return this.get('/guild/user-online-status', {
+            guild_id: guildId,
+            user_id: userId,
+        });
+    }
+    // 获取服务器成员权限
+    async getGuildMemberPermissions(guildId, userId) {
+        return this.get('/guild/user-permissions', {
+            guild_id: guildId,
+            user_id: userId,
+        });
+    }
+    // ========== 批量操作相关扩展接口 ==========
+    // 批量获取频道信息
+    async getChannelsBatch(channelIds) {
+        const result = await this.post('/channel/batch-get-channel-info', {
+            channel_ids: channelIds,
+        });
+        return result.items;
+    }
+    // 批量获取消息信息
+    async getMessagesBatch(msgIds) {
+        const result = await this.post('/message/batch-get-message-info', {
+            msg_ids: msgIds,
+        });
+        return result.items;
+    }
+}
+exports.HttpClient = HttpClient;
+//# sourceMappingURL=http-client.js.map