cqhttp-ts/dist/index.mjs

go-cqhttp的ts开发框架

var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// src/server/linkServer.ts
import { WebSocket } from "ws";

// src/handler/modRun.ts
var modRun_default = (mods, post, id) => {
  mods.forEach((mod) => {
    if (id === void 0) {
      mod.handler(post);
      return;
    }
    if (mod.whiteList === void 0) {
      mod.handler(post);
      return;
    }
    if (typeof mod.whiteList === "boolean") {
      mod.handler(post);
      return;
    }
    if (mod.whiteList.includes(id)) {
      mod.handler(post);
    }
  });
};

// src/handler/Message/friendMessageHandler.ts
var friendMessageMods = [];
var friendMessageHandler_default = (msg) => {
  modRun_default(friendMessageMods, msg, msg.user_id);
};

// src/handler/Message/groupMessageHandler.ts
var groupMessageMods = [];
var groupMessageHandler_default = (msg) => {
  modRun_default(groupMessageMods, msg, msg.group_id);
};

// src/api/tool/createSendPoint.ts
var createSendPoint_default = (pointName, params) => {
  const echo = pointName + (/* @__PURE__ */ new Date()).getTime();
  const paramObj = {};
  for (const item of Object.entries(params)) {
    paramObj[item[0]] = item[1];
  }
  return JSON.stringify({
    action: pointName,
    params: paramObj,
    echo
  });
};

// src/server/bindFunction/bindFriendMessageReply.ts
var bindFriendMessageReply_default = (ws, msgObj) => {
  msgObj.reply = (replyMessage, autoEscape) => {
    if (typeof replyMessage === "number") {
      replyMessage = replyMessage.toString();
    }
    ws.send(
      createSendPoint_default(".handle_quick_operation", {
        context: msgObj,
        operation: {
          reply: replyMessage,
          auto_escape: autoEscape === void 0 ? false : autoEscape
        }
      })
    );
  };
};

// src/server/bindFunction/bindGroupMessageReply.ts
var bindGroupMessageReply_default = (ws, msgObj) => {
  msgObj.reply = (replyMessage, isAt, isDelete, isKick, ban, ban_duration, autoEscape) => {
    if (typeof replyMessage === "number") {
      replyMessage = replyMessage.toString();
    }
    ws.send(
      createSendPoint_default(".handle_quick_operation", {
        context: msgObj,
        operation: {
          reply: replyMessage,
          at_sender: isAt,
          delete: isDelete === void 0 ? false : isDelete,
          kick: isKick === void 0 ? false : isKick,
          ban: ban === void 0 ? false : ban,
          ban_duration: ban === void 0 ? 30 : ban_duration,
          auto_escape: autoEscape === void 0 ? false : autoEscape
        }
      })
    );
  };
};

// src/handler/Notice/groupMessageRecallHandler.ts
var groupMessageRecallMods = [];
var groupMessageRecallHandler_default = (notice) => {
  modRun_default(groupMessageRecallMods, notice, notice.group_id);
};

// src/handler/Notice/clientStatusUpdateHandler.ts
var clientStatusUpdateMods = [];
var clientStatusUpdateHandler_default = (notice) => {
  modRun_default(clientStatusUpdateMods, notice);
};

// src/handler/Notice/friendAddHandler.ts
var friendAddMods = [];
var friendAddHandler_default = (notice) => {
  modRun_default(friendAddMods, notice);
};

// src/handler/Notice/groupAdminUpdateHandler.ts
var groupAdminUpdateMods = [];
var groupAdminUpdateHandler_default = (notice) => {
  modRun_default(groupAdminUpdateMods, notice, notice.user_id);
};

// src/handler/Notice/groupEssenceHandler.ts
var groupEssenceMods = [];
var groupEssenceHandler_default = (notice) => {
  modRun_default(groupEssenceMods, notice, notice.group_id);
};

// src/handler/Notice/friendMessageRecallHandler.ts
var friendMessageRecallMods = [];
var friendMessageRecallHandler_default = (notice) => {
  modRun_default(friendMessageRecallMods, notice, notice.user_id);
};

// src/handler/Notice/groupBanHandler.ts
var groupBanMods = [];
var groupBanHandler_default = (notice) => {
  modRun_default(groupBanMods, notice, notice.group_id);
};

// src/handler/Notice/groupMemberDecreaseHandler.ts
var groupMemberDecreaseMods = [];
var groupMemberDecreaseHandler_default = (notice) => {
  modRun_default(groupMemberDecreaseMods, notice, notice.group_id);
};

// src/handler/Notice/groupMemberIncreaseHandler.ts
var groupMemberIncreaseMods = [];
var groupMemberIncreaseHandler_default = (notice) => {
  modRun_default(groupMemberIncreaseMods, notice, notice.group_id);
};

// src/handler/Notice/groupUploadFileHandler.ts
var groupUploadFileMods = [];
var groupUploadFileHandler_default = (notice) => {
  modRun_default(groupUploadFileMods, notice, notice.group_id);
};

// src/handler/Notice/groupHonorUpdateHandler.ts
var groupHonorUpdateMods = [];
var groupHonorUpdateHandler_default = (notice) => {
  modRun_default(groupHonorUpdateMods, notice, notice.group_id);
};

// src/handler/Notice/groupLuckyKingHandler.ts
var groupLuckyKingMods = [];
var groupLuckyKingHandler_default = (notice) => {
  modRun_default(groupLuckyKingMods, notice, notice.group_id);
};

// src/handler/Notice/groupPokeHandler.ts
var groupPokeMods = [];
var groupPokeHandler_default = (notice) => {
  modRun_default(groupPokeMods, notice, notice.group_id);
};

// src/handler/Notice/receiveOfflineFileHandler.ts
var receiveOfflineMods = [];
var receiveOfflineFileHandler_default = (notice) => {
  modRun_default(receiveOfflineMods, notice, notice.group_id);
};

// src/handler/Request/friendAddRequestHandler.ts
var friendAddRequestMods = [];
var friendAddRequestHandler_default = (request) => {
  modRun_default(friendAddRequestMods, request);
};

// src/handler/Request/groupAddRequestHandler.ts
var groupAddRequestMods = [];
var groupAddRequestHandler_default = (request) => {
  modRun_default(groupAddRequestMods, request);
};

// src/handler/Notice/groupCardUpdateHandler.ts
var groupCardUpdateMods = [];
var groupCardUpdateHandler_default = (notice) => {
  modRun_default(groupCardUpdateMods, notice, notice.group_id);
};

// src/server/linkServer.ts
var CqWebsocket;
function initLinkServer(portOrPath, ip) {
  return new Promise((resolve, reject) => {
    if (typeof portOrPath === "number") {
      CqWebsocket = new WebSocket(`ws://${ip || "localhost"}:${portOrPath}`);
    } else if (typeof portOrPath === "string") {
      CqWebsocket = new WebSocket(portOrPath);
    }
    CqWebsocket.on("error", (err) => {
      reject(err);
    });
    CqWebsocket.on("open", () => __async(this, null, function* () {
      const res = yield CqApi.getLoginInfoApi({});
      if (res.nickname && res.user_id) {
        console.log(`\u8FDE\u63A5\u6210\u529F
\u3010${res.nickname}-${res.user_id}\u3011\u5DF2\u767B\u5F55`);
        resolve(res);
      }
    }));
    CqWebsocket.on("message", (msg) => {
      const data = JSON.parse(msg.toString());
      switch (data.post_type) {
        case "message":
          const message = data;
          if (message.message_type === "private") {
            bindFriendMessageReply_default(CqWebsocket, message);
            friendMessageHandler_default(message);
          } else if (message.message_type === "group") {
            bindGroupMessageReply_default(CqWebsocket, message);
            groupMessageHandler_default(message);
          }
          break;
        case "notice":
          const notice = data;
          switch (notice.notice_type) {
            case "client_status":
              clientStatusUpdateHandler_default(notice);
              break;
            case "essence":
              groupEssenceHandler_default(notice);
              break;
            case "friend_add":
              friendAddHandler_default(notice);
              break;
            case "friend_recall":
              friendMessageRecallHandler_default(notice);
              break;
            case "group_admin":
              groupAdminUpdateHandler_default(notice);
              break;
            case "group_ban":
              groupBanHandler_default(notice);
              break;
            case "group_card":
              groupCardUpdateHandler_default(notice);
              break;
            case "group_decrease":
              groupMemberDecreaseHandler_default(notice);
              break;
            case "group_increase":
              groupMemberIncreaseHandler_default(notice);
              break;
            case "group_recall":
              groupMessageRecallHandler_default(notice);
              break;
            case "group_upload":
              groupUploadFileHandler_default(notice);
              break;
            case "notify":
              const notify = notice;
              switch (notify.sub_type) {
                case "honor":
                  groupHonorUpdateHandler_default(notify);
                  break;
                case "lucky_king":
                  groupLuckyKingHandler_default(notify);
                  break;
                case "poke":
                  groupPokeHandler_default(notify);
                  break;
                default:
                  break;
              }
              break;
            case "offline_file":
              receiveOfflineFileHandler_default(notice);
            default:
              break;
          }
          break;
        case "request":
          const request = data;
          switch (request.request_type) {
            case "friend":
              friendAddRequestHandler_default(request);
              break;
            case "group":
              groupAddRequestHandler_default(request);
              break;
            default:
              break;
          }
        default:
          break;
      }
    });
  });
}
var linkServer = initLinkServer;
var linkServer_default = linkServer;

// src/api/tool/sendAndListen.ts
var sendAndListen_default = (ws, send) => {
  return new Promise((resolve) => {
    const sendObj = JSON.parse(send);
    const echo = sendObj.echo;
    ws.on("message", (res) => {
      const resObj = JSON.parse(res.toString());
      if (resObj.echo === echo) {
        if (resObj.status === "ok") {
          resolve(resObj.data);
        } else {
          resolve(resObj);
        }
      }
    });
    ws.send(JSON.stringify(sendObj));
  });
};

// src/api/sendGroupMessageApi.ts
var sendGroupMessageApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("send_group_msg", param));
};

// src/api/sendPrivateMessageApi.ts
var sendPrivateMessageApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("send_private_msg", param));
};

// src/api/sendGroupForwardMessageApi.ts
var sendGroupForwardMessageApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("send_group_msg", param));
};

// src/api/sendMessageApi.ts
var sendMessageApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("send_msg", param));
};

// src/api/getMessageApi.ts
var getMessageApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_msg", param));
};

// src/api/getImageApi.ts
var getImageApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_image", param));
};

// src/api/getForwardMessageApi.ts
var getForwardMessageApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_forward_msg", param));
};

// src/api/deleteMessageApi.ts
var deleteMessageApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_forward_msg", param));
};

// src/api/markMessageAsReadApi.ts
var markMessageAsReadApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("mark_msg_as_read", param));
};

// src/api/sendGroupSignApi.ts
var sendGroupSignApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("send_group_sign", param));
};

// src/api/setGroupAddRequestApi.ts
var setGroupAddRequestApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("set_group_add_request", param)
  );
};

// src/api/setGroupAdminApi.ts
var setGroupAdminApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("set_group_admin", param));
};

// src/api/setGroupAnonymousApi.ts
var setGroupAnonymousApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("set_group_anonymous", param)
  );
};

// src/api/setGroupAnonymousBanApi.ts
var setGroupAnonymousBanApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("set_group_anonymous_ban", param)
  );
};

// src/api/setGroupBanApi.ts
var setGroupBanApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("set_group_ban", param));
};

// src/api/setGroupCardApi.ts
var setGroupCardApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("set_group_card", param));
};

// src/api/setGroupLeaveApi.ts
var setGroupLeaveApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("set_group_leave", param));
};

// src/api/setGroupNameApi.ts
var setGroupNameApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("set_group_name", param));
};

// src/api/setGroupSpecialTitleApi.ts
var setGroupSpecialTitleApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("set_group_special_title", param)
  );
};

// src/api/setGroupWholeBanApi.ts
var setGroupWholeBanApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("set_group_whole_ban", param)
  );
};

// src/api/setFriendAddRequestApi.ts
var setFriendAddRequestApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("set_friend_add_request", param)
  );
};

// src/api/getLoginInfoApi.ts
var getLoginInfoApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_login_info", param));
};

// src/api/canSendImageApi.ts
var canSendImageApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("can_send_image", param));
};

// src/api/canSendRecordApi.ts
var canSendRecordApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("can_send_record", param));
};

// src/api/checkUrlSafelyApi.ts
var checkUrlSafelyApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("check_url_safely", param));
};

// src/api/cleanCacheApiExpect.ts
var cleanCacheApiExpect_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("clean_cache", param));
};

// src/api/createGroupFileFolderApi.ts
var createGroupFileFolderApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("create_group_file_folder", param)
  );
};

// src/api/deleteEssenceMsgApi.ts
var deleteEssenceMsgApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("delete_essence_msg", param)
  );
};

// src/api/deleteFriendApi.ts
var deleteFriendApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("delete_friend", param));
};

// src/api/deleteGroupFileApi.ts
var deleteGroupFileApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("delete_group_file", param)
  );
};

// src/api/deleteGroupFolderApi.ts
var deleteGroupFolderApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("delete_group_folder", param)
  );
};

// src/api/downloadFileApi.ts
var downloadFileApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("download_file", param));
};

// src/api/getCookiesApiExpect.ts
var getCookiesApiExpect_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_cookies", param));
};

// src/api/getCredentialsApiExpect.ts
var getCredentialsApiExpect_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_credentials", param));
};

// src/api/getCSRFTokenApiExpect.ts
var getCSRFTokenApiExpect_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_csrf_token", param));
};

// src/api/getEssenceMsgListApi.ts
var getEssenceMsgListApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_essence_msg_list", param)
  );
};

// src/api/getFriendListApi.ts
var getFriendListApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_friend_list", param));
};

// src/api/getGroupAtAllRemainApi.ts
var getGroupAtAllRemainApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_group_at_all_remain", param)
  );
};

// src/api/getGroupFilesByFolderApi.ts
var getGroupFilesByFolderApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_group_files_by_folder", param)
  );
};

// src/api/getGroupFileUrlApi.ts
var getGroupFileUrlApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_group_file_url", param)
  );
};

// src/api/getGroupHonorInfoApi.ts
var getGroupHonorInfoApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_group_honor_info", param)
  );
};

// src/api/getGroupInfoApi.ts
var getGroupInfoApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_group_info", param));
};

// src/api/getGroupListApi.ts
var getGroupListApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_group_list", param));
};

// src/api/getGroupMemberListApi.ts
var getGroupMemberListApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_group_member_list", param)
  );
};

// src/api/getGroupMessageHistoryApi.ts
var getGroupMessageHistoryApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_group_msg_history", param)
  );
};

// src/api/getGroupNoticeApi.ts
var getGroupNoticeApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("_get_group_notice", param)
  );
};

// src/api/getGroupRootFilesApi.ts
var getGroupRootFilesApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_group_root_files", param)
  );
};

// src/api/getGroupSystemMsgApi.ts
var getGroupSystemMsgApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_group_system_msg", param)
  );
};

// src/api/getGroupFileSystemInfoApi.ts
var getGroupFileSystemInfoApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_group_file_system_info", param)
  );
};

// src/api/getModelShowApi.ts
var getModelShowApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("_get_model_show", param));
};

// src/api/getOnlineClientsApi.ts
var getOnlineClientsApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_online_clients", param)
  );
};

// src/api/getRecordApiExpect.ts
var getRecordApiExpect_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_record", param));
};

// src/api/getStatusApi.ts
var getStatusApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_status", param));
};

// src/api/getStrangerInfoApi.ts
var getStrangerInfoApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_stranger_info", param)
  );
};

// src/api/getUnidirectionalFriendListApi.ts
var getUnidirectionalFriendListApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("get_unidirectional_friend_list", param)
  );
};

// src/api/getVersionInfoApi.ts
var getVersionInfoApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("get_version_info", param));
};

// src/api/ocrImageApi.ts
var ocrImageApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default(".ocr_image", param));
};

// src/api/reloadEventFilterApi.ts
var reloadEventFilterApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default(".reload_event_filter", param)
  );
};

// src/api/sendGroupNoticeApi.ts
var sendGroupNoticeApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("_send_group_notice", param)
  );
};

// src/api/setEssenceMsgApi.ts
var setEssenceMsgApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("set_essence_msg", param));
};

// src/api/setGroupPortraitApi.ts
var setGroupPortraitApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("set_group_portrait", param)
  );
};

// src/api/setModelShowApi.ts
var setModelShowApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("_set_model_show", param));
};

// src/api/setQQProfileApi.ts
var setQQProfileApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("set_qq_profile", param));
};

// src/api/setRestartApi.ts
var setRestartApi_default = (param) => {
  return sendAndListen_default(CqWebsocket, createSendPoint_default("set_restart", param));
};

// src/api/uploadGroupFileApi.ts
var uploadGroupFileApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("upload_group_file", param)
  );
};

// src/api/uploadPrivateFileApi.ts
var uploadPrivateFileApi_default = (param) => {
  return sendAndListen_default(
    CqWebsocket,
    createSendPoint_default("upload_private_file", param)
  );
};

// src/api/index.ts
var CqApi = {
  canSendImageApi: canSendImageApi_default,
  canSendRecordApi: canSendRecordApi_default,
  checkUrlSafelyApi: checkUrlSafelyApi_default,
  cleanCacheApiExpect: cleanCacheApiExpect_default,
  createGroupFileFolderApi: createGroupFileFolderApi_default,
  deleteEssenceMsgApi: deleteEssenceMsgApi_default,
  deleteFriendApi: deleteFriendApi_default,
  deleteGroupFileApi: deleteGroupFileApi_default,
  deleteGroupFolderApi: deleteGroupFolderApi_default,
  deleteMessageApi: deleteMessageApi_default,
  downloadFileApi: downloadFileApi_default,
  getCookiesApiExpect: getCookiesApiExpect_default,
  getCredentialsApiExpect: getCredentialsApiExpect_default,
  getCSRFTokenApiExpect: getCSRFTokenApiExpect_default,
  getEssenceMsgListApi: getEssenceMsgListApi_default,
  GetForwardMessageApi: getForwardMessageApi_default,
  getFriendListApi: getFriendListApi_default,
  getGroupAtAllRemainApi: getGroupAtAllRemainApi_default,
  getGroupFileSystemInfoApi: getGroupFileSystemInfoApi_default,
  getGroupFilesByFolderApi: getGroupFilesByFolderApi_default,
  getGroupFileUrlApi: getGroupFileUrlApi_default,
  getGroupHonorInfoApi: getGroupHonorInfoApi_default,
  getGroupInfoApi: getGroupInfoApi_default,
  getGroupListApi: getGroupListApi_default,
  getGroupMemberListApi: getGroupMemberListApi_default,
  getGroupMessageHistoryApi: getGroupMessageHistoryApi_default,
  getGroupNoticeApi: getGroupNoticeApi_default,
  getGroupRootFilesApi: getGroupRootFilesApi_default,
  getGroupSystemMsgApi: getGroupSystemMsgApi_default,
  getImageApi: getImageApi_default,
  getLoginInfoApi: getLoginInfoApi_default,
  getMessageApi: getMessageApi_default,
  getModelShowApi: getModelShowApi_default,
  getOnlineClientsApi: getOnlineClientsApi_default,
  getRecordApiExpect: getRecordApiExpect_default,
  getStatusApi: getStatusApi_default,
  getStrangerInfoApi: getStrangerInfoApi_default,
  getUnidirectionalFriendListApi: getUnidirectionalFriendListApi_default,
  getVersionInfoApi: getVersionInfoApi_default,
  markMessageAsReadApi: markMessageAsReadApi_default,
  ocrImageApi: ocrImageApi_default,
  reloadEventFilterApi: reloadEventFilterApi_default,
  sendGroupForwardMessageApi: sendGroupForwardMessageApi_default,
  sendGroupMessageApi: sendGroupMessageApi_default,
  sendGroupNoticeApi: sendGroupNoticeApi_default,
  sendGroupSignApi: sendGroupSignApi_default,
  sendMessageApi: sendMessageApi_default,
  sendPrivateMessageApi: sendPrivateMessageApi_default,
  setEssenceMsgApi: setEssenceMsgApi_default,
  setFriendAddRequestApi: setFriendAddRequestApi_default,
  setGroupAddRequestApi: setGroupAddRequestApi_default,
  setGroupAdminApi: setGroupAdminApi_default,
  setGroupAnonymousApi: setGroupAnonymousApi_default,
  setGroupAnonymousBanApi: setGroupAnonymousBanApi_default,
  setGroupBanApi: setGroupBanApi_default,
  setGroupCardApi: setGroupCardApi_default,
  setGroupLeaveApi: setGroupLeaveApi_default,
  setGroupNameApi: setGroupNameApi_default,
  setGroupPortraitApi: setGroupPortraitApi_default,
  setGroupSpecialTitleApi: setGroupSpecialTitleApi_default,
  setGroupWholeBanApi: setGroupWholeBanApi_default,
  setModelShowApi: setModelShowApi_default,
  setQQProfileApi: setQQProfileApi_default,
  setRestartApi: setRestartApi_default,
  uploadGroupFileApi: uploadGroupFileApi_default,
  uploadPrivateFileApi: uploadPrivateFileApi_default
};

// src/modMonitor.ts
var messageModStore = [];
var noticeModStore = [];
var requestModStore = [];

// src/handler/Message/useMessageMod.ts
var useMessageMod = (mod) => {
  if (mod instanceof Array) {
    mod.forEach((item) => {
      if (item.handler === void 0)
        return;
      switch (item.type) {
        case "friendMessageMod":
          friendMessageMods.push(item);
          break;
        case "groupMessageMod":
          groupMessageMods.push(item);
          break;
      }
      messageModStore.push(item);
    });
  }
};

// src/handler/Notice/friendPokeHandler.ts
var friendPokeMods = [];

// src/handler/Notice/useNoticeMod.ts
var useNoticeMod = (mod) => {
  if (mod instanceof Array) {
    mod.forEach((item) => {
      if (item.handler === void 0)
        return;
      switch (item.type) {
        case "groupMessageRecallMod":
          groupMessageRecallMods.push(item);
          break;
        case "friendAddMod":
          friendAddMods.push(item);
          break;
        case "clientStatusUpdateMod":
          clientStatusUpdateMods.push(item);
          break;
        case "groupBanMod":
          groupBanMods.push(item);
          break;
        case "friendPokeMod":
          friendPokeMods.push(item);
          break;
        case "groupAdminUpdateMod":
          groupAdminUpdateMods.push(item);
          break;
        case "groupCardUpdateMod":
          groupCardUpdateMods.push(item);
          break;
        case "groupEssenceMod":
          groupEssenceMods.push(item);
          break;
        case "groupHonorUpdateMod":
          groupHonorUpdateMods.push(item);
          break;
        case "groupLuckyKingMod":
          groupLuckyKingMods.push(item);
          break;
        case "groupMemberDecreaseMod":
          groupMemberDecreaseMods.push(item);
          break;
        case "groupMemberIncreaseMod":
          groupMemberIncreaseMods.push(item);
          break;
        case "groupPokeMod":
          groupPokeMods.push(item);
          break;
        case "groupUploadFileMod":
          groupUploadFileMods.push(item);
          break;
        case "receiveOfflineFileMod":
          receiveOfflineMods.push(item);
          break;
      }
      noticeModStore.push(item);
    });
    return;
  }
};

// src/types/index.ts
var types_exports = {};

// src/types/Mod/index.ts
var Mod_exports = {};

// src/types/api/index.ts
var api_exports = {};

// src/index.ts
var src_default = linkServer_default;
var useMod = { useMessageMod, useNoticeMod };
var modMonitor = { messageModStore, noticeModStore, requestModStore };
export {
  CqApi,
  Mod_exports as ModTypes,
  types_exports as PostTypes,
  api_exports as apis,
  src_default as default,
  modMonitor,
  useMod
};
//# sourceMappingURL=index.mjs.map