feat(napcat): 补充全部群事件处理与事件定义

新增近 30 个群相关事件处理器，覆盖群信息、成员管理、禁言、公告、精华消息等功能；修正合并转发消息事件常量拼写；补全事件类型注解与详细文档。所有群事件统一使用 `NapcatEvent.GROUP.*` 枚举值与对应 Handler。

plugins/napcat_adapter_plugin/event_handlers.py

@@ -549,6 +549,7 @@ class SetDiyOnlineStatusHandler(BaseEventHandler):
             return HandlerResult(False, False, {"status": "error"})
 
 
+# ===MESSAGE===
 class SendPrivateMsgHandler(BaseEventHandler):
     handler_name: str = "napcat_send_private_msg_handler"
     handler_description: str = "发送私聊消息"
@@ -856,7 +857,7 @@ class SendForwardMsgHandler(BaseEventHandler):
     handler_description: str = "发送合并转发消息"
     weight: int = 100
     intercept_message: bool = False
-    init_subscribe = [NapcatEvent.MESSAGE.SEND_FORWARF_MSG]
+    init_subscribe = [NapcatEvent.MESSAGE.SEND_FORWARD_MSG]
 
     async def execute(self, params: dict):
         raw = params.get("raw", {})
@@ -934,3 +935,925 @@ class SendGroupAiRecordHandler(BaseEventHandler):
         else:
             logger.error("事件 napcat_send_group_ai_record 请求失败！")
             return HandlerResult(False, False, {"status": "error"})
+
+# ===GROUP===
+class GetGroupInfoHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_info_handler"
+    handler_description: str = "获取群信息"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_INFO]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+
+        if not group_id:
+            logger.error("事件 napcat_get_group_info 缺少必要参数: group_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_group_info", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_info 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupAddOptionHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_add_option_handler"
+    handler_description: str = "设置群添加选项"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_ADD_OPTION]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        add_type = params.get("add_type", "")
+        group_question = params.get("group_question", "")
+        group_answer = params.get("group_answer", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            add_type = raw.get("add_type", "")
+            group_question = raw.get("group_question", "")
+            group_answer = raw.get("group_answer", "")
+
+        if not group_id or not add_type:
+            logger.error("事件 napcat_set_group_add_option 缺少必要参数: group_id 或 add_type")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "add_type": str(add_type)
+        }
+        if group_question:
+            payload["group_question"] = group_question
+        if group_answer:
+            payload["group_answer"] = group_answer
+
+        response = await send_handler.send_message_to_napcat(action="set_group_add_option", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_add_option 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupKickMembersHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_kick_members_handler"
+    handler_description: str = "批量踢出群成员"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_KICK_MEMBERS]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        user_id = params.get("user_id", [])
+        reject_add_request = params.get("reject_add_request", False)
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            user_id = raw.get("user_id", [])
+            reject_add_request = raw.get("reject_add_request", False)
+
+        if not group_id or not user_id:
+            logger.error("事件 napcat_set_group_kick_members 缺少必要参数: group_id 或 user_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "user_id": user_id,
+            "reject_add_request": bool(reject_add_request)
+        }
+        response = await send_handler.send_message_to_napcat(action="set_group_kick_members", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_kick_members 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupRemarkHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_remark_handler"
+    handler_description: str = "设置群备注"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_REMARK]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        remark = params.get("remark", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            remark = raw.get("remark", "")
+
+        if not group_id or not remark:
+            logger.error("事件 napcat_set_group_remark 缺少必要参数: group_id 或 remark")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "remark": remark
+        }
+        response = await send_handler.send_message_to_napcat(action="set_group_remark", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_remark 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupKickHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_kick_handler"
+    handler_description: str = "群踢人"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_KICK]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        user_id = params.get("user_id", "")
+        reject_add_request = params.get("reject_add_request", False)
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            user_id = raw.get("user_id", "")
+            reject_add_request = raw.get("reject_add_request", False)
+
+        if not group_id or not user_id:
+            logger.error("事件 napcat_set_group_kick 缺少必要参数: group_id 或 user_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "user_id": str(user_id),
+            "reject_add_request": bool(reject_add_request)
+        }
+        response = await send_handler.send_message_to_napcat(action="set_group_kick", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_kick 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetGroupSystemMsgHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_system_msg_handler"
+    handler_description: str = "获取群系统消息"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_SYSTEM_MSG]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        count = params.get("count", 20)
+
+        if params.get("raw", ""):
+            count = raw.get("count", 20)
+
+        if count is None:
+            logger.error("事件 napcat_get_group_system_msg 缺少必要参数: count")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "count": int(count)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_group_system_msg", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_system_msg 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupBanHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_ban_handler"
+    handler_description: str = "群禁言"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_BAN]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        user_id = params.get("user_id", "")
+        duration = params.get("duration", 0)
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            user_id = raw.get("user_id", "")
+            duration = raw.get("duration", 0)
+
+        if not group_id or not user_id or duration is None:
+            logger.error("事件 napcat_set_group_ban 缺少必要参数")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "user_id": str(user_id),
+            "duration": int(duration)
+        }
+        response = await send_handler.send_message_to_napcat(action="set_group_ban", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_ban 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetEssenceMsgListHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_essence_msg_list_handler"
+    handler_description: str = "获取群精华消息"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_ESSENCE_MSG_LIST]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+
+        if not group_id:
+            logger.error("事件 napcat_get_essence_msg_list 缺少必要参数: group_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_essence_msg_list", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_essence_msg_list 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupWholeBanHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_whole_ban_handler"
+    handler_description: str = "全体禁言"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_WHOLE_BAN]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        enable = params.get("enable", True)
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            enable = raw.get("enable", True)
+
+        if not group_id or enable is None:
+            logger.error("事件 napcat_set_group_whole_ban 缺少必要参数")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "enable": bool(enable)
+        }
+        response = await send_handler.send_message_to_napcat(action="set_group_whole_ban", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_whole_ban 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupPortraitHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_portrait_handler"
+    handler_description: str = "设置群头像"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_PORTRAINT]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        file_path = params.get("file", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            file_path = raw.get("file", "")
+
+        if not group_id or not file_path:
+            logger.error("事件 napcat_set_group_portrait 缺少必要参数: group_id 或 file")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "file": file_path
+        }
+        response = await send_handler.send_message_to_napcat(action="set_group_portrait", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_portrait 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupAdminHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_admin_handler"
+    handler_description: str = "设置群管理"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_ADMIN]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        user_id = params.get("user_id", "")
+        enable = params.get("enable", True)
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            user_id = raw.get("user_id", "")
+            enable = raw.get("enable", True)
+
+        if not group_id or not user_id or enable is None:
+            logger.error("事件 napcat_set_group_admin 缺少必要参数")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "user_id": str(user_id),
+            "enable": bool(enable)
+        }
+        response = await send_handler.send_message_to_napcat(action="set_group_admin", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_admin 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupCardHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_card_handler"
+    handler_description: str = "设置群成员名片"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_CARD]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        user_id = params.get("user_id", "")
+        card = params.get("card", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            user_id = raw.get("user_id", "")
+            card = raw.get("card", "")
+
+        if not group_id or not user_id:
+            logger.error("事件 napcat_set_group_card 缺少必要参数: group_id 或 user_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "user_id": str(user_id)
+        }
+        if card:
+            payload["card"] = card
+
+        response = await send_handler.send_message_to_napcat(action="group_card", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_card 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetEssenceMsgHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_essence_msg_handler"
+    handler_description: str = "设置群精华消息"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_ESSENCE_MSG]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        message_id = params.get("message_id", "")
+
+        if params.get("raw", ""):
+            message_id = raw.get("message_id", "")
+
+        if not message_id:
+            logger.error("事件 napcat_set_essence_msg 缺少必要参数: message_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "message_id": str(message_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="set_essence_msg", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_essence_msg 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupNameHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_name_handler"
+    handler_description: str = "设置群名"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_NAME]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        group_name = params.get("group_name", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            group_name = raw.get("group_name", "")
+
+        if not group_id or not group_name:
+            logger.error("事件 napcat_set_group_name 缺少必要参数: group_id 或 group_name")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "group_name": group_name
+        }
+        response = await send_handler.send_message_to_napcat(action="set_group_name", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_name 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class DeleteEssenceMsgHandler(BaseEventHandler):
+    handler_name: str = "napcat_delete_essence_msg_handler"
+    handler_description: str = "删除群精华消息"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.DELETE_ESSENCE_MSG]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        message_id = params.get("message_id", "")
+
+        if params.get("raw", ""):
+            message_id = raw.get("message_id", "")
+
+        if not message_id:
+            logger.error("事件 napcat_delete_essence_msg 缺少必要参数: message_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "message_id": str(message_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="delete_essence_msg", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_delete_essence_msg 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupLeaveHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_leave_handler"
+    handler_description: str = "退群"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_LEAVE]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+
+        if not group_id:
+            logger.error("事件 napcat_set_group_leave 缺少必要参数: group_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="set_group_leave", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_leave 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SendGroupNoticeHandler(BaseEventHandler):
+    handler_name: str = "napcat_send_group_notice_handler"
+    handler_description: str = "发送群公告"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SEND_GROUP_NOTICE]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        content = params.get("content", "")
+        image = params.get("image", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            content = raw.get("content", "")
+            image = raw.get("image", "")
+
+        if not group_id or not content:
+            logger.error("事件 napcat_send_group_notice 缺少必要参数: group_id 或 content")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "content": content
+        }
+        if image:
+            payload["image"] = image
+
+        response = await send_handler.send_message_to_napcat(action="_send_group_notice", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_send_group_notice 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupSpecialTitleHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_special_title_handler"
+    handler_description: str = "设置群头衔"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_SPECIAL_TITLE]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        user_id = params.get("user_id", "")
+        special_title = params.get("special_title", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            user_id = raw.get("user_id", "")
+            special_title = raw.get("special_title", "")
+
+        if not group_id or not user_id:
+            logger.error("事件 napcat_set_group_special_title 缺少必要参数: group_id 或 user_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "user_id": str(user_id)
+        }
+        if special_title:
+            payload["special_title"] = special_title
+
+        response = await send_handler.send_message_to_napcat(action="set_group_special_title", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_special_title 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetGroupNoticeHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_notice_handler"
+    handler_description: str = "获取群公告"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_NOTICE]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+
+        if not group_id:
+            logger.error("事件 napcat_get_group_notice 缺少必要参数: group_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="_get_group_notice", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_notice 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupAddRequestHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_add_request_handler"
+    handler_description: str = "处理加群请求"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_ADD_REQUEST]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        flag = params.get("flag", "")
+        approve = params.get("approve", True)
+        reason = params.get("reason", "")
+
+        if params.get("raw", ""):
+            flag = raw.get("flag", "")
+            approve = raw.get("approve", True)
+            reason = raw.get("reason", "")
+
+        if not flag or approve is None:
+            logger.error("事件 napcat_set_group_add_request 缺少必要参数")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "flag": flag,
+            "approve": bool(approve)
+        }
+        if reason:
+            payload["reason"] = reason
+
+        response = await send_handler.send_message_to_napcat(action="set_group_add_request", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_add_request 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetGroupListHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_list_handler"
+    handler_description: str = "获取群列表"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_LIST]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        no_cache = params.get("no_cache", False)
+
+        if params.get("raw", ""):
+            no_cache = raw.get("no_cache", False)
+
+        payload = {
+            "no_cache": bool(no_cache)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_group_list", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_list 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class DeleteGroupNoticeHandler(BaseEventHandler):
+    handler_name: str = "napcat_del_group_notice_handler"
+    handler_description: str = "删除群公告"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.DELETE_GROUP_NOTICE]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        notice_id = params.get("notice_id", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            notice_id = raw.get("notice_id", "")
+
+        if not group_id or not notice_id:
+            logger.error("事件 napcat_del_group_notice 缺少必要参数: group_id 或 notice_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "notice_id": notice_id
+        }
+        response = await send_handler.send_message_to_napcat(action="_del_group_notice", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_del_group_notice 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetGroupMemberInfoHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_member_info_handler"
+    handler_description: str = "获取群成员信息"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_MEMBER_INFO]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        user_id = params.get("user_id", "")
+        no_cache = params.get("no_cache", False)
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            user_id = raw.get("user_id", "")
+            no_cache = raw.get("no_cache", False)
+
+        if not group_id or not user_id:
+            logger.error("事件 napcat_get_group_member_info 缺少必要参数: group_id 或 user_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "user_id": str(user_id),
+            "no_cache": bool(no_cache)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_group_member_info", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_member_info 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetGroupMemberListHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_member_list_handler"
+    handler_description: str = "获取群成员列表"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_MEMBER_LIST]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        no_cache = params.get("no_cache", False)
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            no_cache = raw.get("no_cache", False)
+
+        if not group_id:
+            logger.error("事件 napcat_get_group_member_list 缺少必要参数: group_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id),
+            "no_cache": bool(no_cache)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_group_member_list", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_member_list 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetGroupHonorInfoHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_honor_info_handler"
+    handler_description: str = "获取群荣誉"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_HONOR_INFO]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+        type = params.get("type", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+            type = raw.get("type", "")
+
+        if not group_id:
+            logger.error("事件 napcat_get_group_honor_info 缺少必要参数: group_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id)
+        }
+        if type:
+            payload["type"] = type
+
+        response = await send_handler.send_message_to_napcat(action="get_group_honor_info", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_honor_info 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetGroupInfoExHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_info_ex_handler"
+    handler_description: str = "获取群信息ex"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_INFO_EX]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+
+        if not group_id:
+            logger.error("事件 napcat_get_group_info_ex 缺少必要参数: group_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_group_info_ex", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_info_ex 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetGroupAtAllRemainHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_at_all_remain_handler"
+    handler_description: str = "获取群 @全体成员 剩余次数"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_AT_ALL_REMAIN]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+
+        if not group_id:
+            logger.error("事件 napcat_get_group_at_all_remain 缺少必要参数: group_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_group_at_all_remain", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_at_all_remain 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetGroupShutListHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_shut_list_handler"
+    handler_description: str = "获取群禁言列表"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_SHUT_LIST]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+
+        if not group_id:
+            logger.error("事件 napcat_get_group_shut_list 缺少必要参数: group_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_group_shut_list", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_shut_list 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class GetGroupIgnoredNotifiesHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_group_ignored_notifies_handler"
+    handler_description: str = "获取群过滤系统消息"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.GET_GROUP_IGNORED_NOTIFIES]
+
+    async def execute(self, params: dict):
+        payload = {}
+        response = await send_handler.send_message_to_napcat(action="get_group_ignored_notifies", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_group_ignored_notifies 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+class SetGroupSignHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_group_sign_handler"
+    handler_description: str = "群打卡"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.GROUP.SET_GROUP_SIGN]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        group_id = params.get("group_id", "")
+
+        if params.get("raw", ""):
+            group_id = raw.get("group_id", "")
+
+        if not group_id:
+            logger.error("事件 napcat_set_group_sign 缺少必要参数: group_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "group_id": str(group_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="set_group_sign", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_group_sign 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})

plugins/napcat_adapter_plugin/event_types.py

@@ -320,7 +320,7 @@ class NapcatEvent(Enum):
         '''获取好友列表
         
         Args:
-            no_cache (Opetional[bool]): 是否不使用缓存
+            no_cache (Optional[bool]): 是否不使用缓存
             raw (Optional[dict]): 原始请求体
         
         Returns:
@@ -352,9 +352,9 @@ class NapcatEvent(Enum):
         '''获取点赞列表
         
         Args:
-            user_id (Opetional[str|int]): 用户id,指定用户,不填为获取所有
+            user_id (Optional[str|int]): 用户id,指定用户,不填为获取所有
-            start (Opetional[int]): 起始值
+            start (Optional[int]): 起始值
-            count (Opetional[int]): 返回数量
+            count (Optional[int]): 返回数量
             raw (Optional[dict]): 原始请求体
 
         Returns:
@@ -425,9 +425,9 @@ class NapcatEvent(Enum):
         '''删除好友
         
         Args:
-            user_id (Opetional[str|int]): 用户id(必需)
+            user_id (Optional[str|int]): 用户id(必需)
-            temp_block (Opetional[bool]): 拉黑(必需)
+            temp_block (Optional[bool]): 拉黑(必需)
-            temp_both_del (Opetional[bool]): 双向删除(必需)
+            temp_both_del (Optional[bool]): 双向删除(必需)
             raw (Optional[dict]): 原始请求体
         
         Returns:
@@ -447,7 +447,7 @@ class NapcatEvent(Enum):
         '''获取(指定)用户状态
         
         Args:
-            user_id (Opetional[str|int]): 用户id(必需)
+            user_id (Optional[str|int]): 用户id(必需)
             raw (Optional[dict]): 原始请求体
         
         Returns:
@@ -568,8 +568,8 @@ class NapcatEvent(Enum):
         '''发送私聊消息
         
         Args:
-            user_id (Opetional[str|int]): 用户id(必需)
+            user_id (Optional[str|int]): 用户id(必需)
-            message (Opetional[str]): 消息object(必需)
+            message (Optional[str]): 消息object(必需)
             raw (Optional[dict]): 原始请求体
         
         Returns:
@@ -884,7 +884,7 @@ class NapcatEvent(Enum):
             "echo": "string"
         }
         '''
-        SEND_FORWARF_MSG = "napcat_send_forward_msg"    
+        SEND_FORWARD_MSG = "napcat_send_forward_msg"    
         '''发送合并转发消息
         
         Args:
@@ -929,73 +929,886 @@ class NapcatEvent(Enum):
         }
         '''
 
+
     class GROUP(Enum):
         """
         该分类是对群聊相关的操作，只能由外部触发，napcat_plugin负责处理
         """
-        SET_GROUP_SEARCH = "napcat_set_group_search"
+        GET_GROUP_INFO = "napcat_get_group_info"  
-        '''设置群搜索'''
+        '''获取群信息
-        GET_GROUP_DETAIL_INFO = "napcat_get_group_detail_info"  
+        
-        '''获取群详细信息'''
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            raw (Optional[dict]): 原始请求体
+
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "group_all_shut": 0,
+                "group_remark": "string",
+                "group_id": "string",
+                "group_name": "string",
+                "member_count": 0,
+                "max_member_count": 0
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_GROUP_ADD_OPTION = "napcat_set_group_add_option"    
-        '''设置群添加选项'''
+        '''设置群添加选项
-        SET_GROUP_ROBOT_ADD_OPTION = "napcat_set_group_robot_add_option"    
+        
-        '''设置群机器人添加选项'''
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            add_type (Optional[str]): 群添加类型(必需)
+            group_question (Optional[str]): 群添加问题
+            group_answer (Optional[str]): 群添加答案
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_GROUP_KICK_MEMBERS = "napcat_set_group_kick_members"    
-        '''批量踢出群成员'''
+        '''批量踢出群成员
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            user_id (Optional[List[str|int]]): 用户id列表(必需)
+            reject_add_request (Optional[bool]): 是否群拉黑
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
+        SET_GROUP_REMARK = "napcat_set_group_remark"
+        '''设置群备注
+
+        Args:
+            group_id (Optional[str]): 群号(必需)
+            remark (Optional[str]): 备注内容(必需)
+            raw (Optional[dict]): 原始请求体
+
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }     
+        ''' 
         SET_GROUP_KICK = "napcat_set_group_kick"    
-        '''群踢人'''
+        '''群踢人
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            user_id (Optional[str|int]): 用户id(必需)
+            reject_add_request (Optional[bool]): 是否群拉黑
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_GROUP_SYSTEM_MSG = "napcat_get_group_system_msg"    
-        '''获取群系统消息'''
+        '''获取群系统消息
+        
+        Args:
+            count (Optional[int]): 获取数量(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "InvitedRequest": [
+                    {
+                        "request_id": 0,
+                        "invitor_uin": 0,
+                        "invitor_nick": "string",
+                        "group_id": 0,
+                        "message": "string",
+                        "group_name": "string",
+                        "checked": true,
+                        "actor": 0,
+                        "requester_nick": "string"
+                    }
+                ],
+                "join_requests": [
+                    {
+                        "request_id": 0,
+                        "invitor_uin": 0,
+                        "invitor_nick": "string",
+                        "group_id": 0,
+                        "message": "string",
+                        "group_name": "string",
+                        "checked": true,
+                        "actor": 0,
+                        "requester_nick": "string"
+                    }
+                ]
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_GROUP_BAN = "napcat_set_group_ban"  
-        '''群禁言'''
+        '''群禁言
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            user_id (Optional[str|int]): 用户id(必需)
+            duration (Optional[int]): 禁言时间：秒(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_ESSENCE_MSG_LIST = "napcat_get_essence_msg_list"    
-        '''获取群精华消息'''
+        '''获取群精华消息
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": [
+                {
+                    "msg_seq": 0,
+                    "msg_random": 0,
+                    "sender_id": 0,
+                    "sender_nick": "string",
+                    "operator_id": 0,
+                    "operator_nick": "string",
+                    "message_id": 0,
+                    "operator_time": 0,
+                    "content": [
+                        {
+                            "type": "text",
+                            "data": {
+                                "text": "string"
+                            }
+                        }
+                    ]
+                }
+            ],
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_GROUP_WHOLE_BAN = "napcat_set_group_whole_ban"  
-        '''全体禁言'''
+        '''全体禁言
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            enable (Optional[bool]): 是否启用(必需)
+            raw (Optional[dict]): 原始请求体
+
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_GROUP_PORTRAINT = "napcat_set_group_portrait"   
-        '''设置群头像'''
+        '''设置群头像
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            file (Optional[str]): 文件路径(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "result": 0,
+                "errMsg": "success"
+            },
+            "message": "",
+            "wording": "",
+            "echo": null
+        }
+        '''
         SET_GROUP_ADMIN = "napcat_set_group_admin"  
-        '''设置群管理'''
+        '''设置群管理
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            user_id (Optional[str|int]): 用户id(必需)
+            enable (Optional[bool]): 是否设为群管理(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_GROUP_CARD = "napcat_group_card"    
-        '''设置群成员名片'''
+        '''设置群成员名片
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            user_id (Optional[str|int]): 用户id(必需)
+            card (Optional[str]): 为空则为取消群名片
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_ESSENCE_MSG = "napcat_set_essence_msg"  
-        '''设置群精华消息'''
+        '''设置群精华消息
+        
+        Args:
+            message_id (Optional[str|int]): 消息id(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "errCode": 0,
+                "errMsg": "success",
+                "result": {
+                    "wording": "",
+                    "digestUin": "0",
+                    "digestTime": 0,
+                    "msg": {
+                        "groupCode": "0",
+                        "msgSeq": 0,
+                        "msgRandom": 0,
+                        "msgContent": [],
+                        "textSize": "0",
+                        "picSize": "0",
+                        "videoSize": "0",
+                        "senderUin": "0",
+                        "senderTime": 0,
+                        "addDigestUin": "0",
+                        "addDigestTime": 0,
+                        "startTime": 0,
+                        "latestMsgSeq": 0,
+                        "opType": 0
+                    },
+                    "errorCode": 0
+                }
+            },
+            "message": "",
+            "wording": "",
+            "echo": null
+        }
+        '''
         SET_GROUP_NAME = "napcat_set_group_name"    
-        '''设置群名'''
+        '''设置群名
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            group_name (Optional[str]): 群名(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         DELETE_ESSENCE_MSG = "napcat_delete_essence_msg"    
-        '''删除群精华消息'''
+        '''删除群精华消息
+        
+        Args:
+            message_id (Optional[str|int]): 消息id(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict:{
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "errCode": 0,
+                "errMsg": "success",
+                "result": {
+                    "wording": "",
+                    "digestUin": "0",
+                    "digestTime": 0,
+                    "msg": {
+                        "groupCode": "0",
+                        "msgSeq": 0,
+                        "msgRandom": 0,
+                        "msgContent": [],
+                        "textSize": "0",
+                        "picSize": "0",
+                        "videoSize": "0",
+                        "senderUin": "0",
+                        "senderTime": 0,
+                        "addDigestUin": "0",
+                        "addDigestTime": 0,
+                        "startTime": 0,
+                        "latestMsgSeq": 0,
+                        "opType": 0
+                    },
+                    "errorCode": 0
+                }
+            },
+            "message": "",
+            "wording": "",
+            "echo": null
+        }
+        '''
         SET_GROUP_LEAVE = "napcat_set_group_leave"  
-        '''退群'''
+        '''退群
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SEND_GROUP_NOTICE = "napcat_group_notice"   
-        '''发送群公告'''
+        '''发送群公告
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            content (Optional[str]): 公告内容(必需)
+            image (Optional[str]): 图片地址
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_GROUP_SPECIAL_TITLE = "napcat_set_group_special_title"  
-        '''设置群头衔'''
+        '''设置群头衔
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            user_id (Optional[str|int]): 用户id(必需)
+            special_title (Optional[str]): 为空则取消头衔
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_GROUP_NOTICE = "napcat_get_group_notice"    
-        '''获取群公告'''
+        '''获取群公告
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": [
+                {
+                    "notice_id": "63491e2f000000004f4d1e677d2b0200",
+                    "sender_id": 123,
+                    "publish_time": 1730039119,
+                    "message": {
+                        "text": "这是一条神奇的群公告",
+                        "image": [
+                            {
+                                "id": "aJJBbZ6BqyLiaC1kmpvIWGBBkJerEfpRBHX5Brxbaurs",
+                                "height": "400",
+                                "width": "400"
+                            }
+                        ]
+                    }
+                }
+            ],
+            "message": "",
+            "wording": "",
+            "echo": null
+        }
+        '''
         SET_GROUP_ADD_REQUEST = "napcat_set_group_add_request"  
-        '''处理加群请求'''
+        '''处理加群请求
-        GET_GROUP_INFO = "napcat_get_group_info"    
+        
-        '''获取群信息'''
+        Args:
+            flag (Optional[str]): 请求id(必需)
+            approve (Optional[bool]): 是否同意(必需)
+            reason (Optional[str]): 拒绝理由
+            raw (Optional[dict]): 原始请求体
+
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_GROUP_LIST = "napcat_get_group_list"    
-        '''获取群列表'''
+        '''获取群列表
+        
+        Args:
+            no_cache (Optional[bool]): 是否不缓存
+            raw (Optional[dict]): 原始请求体  
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": [
+                {
+                    "group_all_shut": 0,
+                    "group_remark": "string",
+                    "group_id": "string",
+                    "group_name": "string",
+                    "member_count": 0,
+                    "max_member_count": 0
+                }
+            ],
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }   
+        '''
         DELETE_GROUP_NOTICE = "napcat_del_group_notice"
-        '''删除群公告'''
+        '''删除群公告
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            notice_id (Optional[str]): 公告id(必需)
+            raw (Optional[dict]): 原始请求体  
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "result": 0,
+                "errMsg": "string"
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_GROUP_MEMBER_INFO = "napcat_get_group_member_info"
-        '''获取群成员信息'''
+        '''获取群成员信息
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            user_id (Optional[str|int]): 用户id(必需)
+            no_cache (Optional[bool]): 是否不缓存
+            raw (Optional[dict]): 原始请求体 
+    
+        Returns:
+            dict:{
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "group_id": 0,
+                "user_id": 0,
+                "nickname": "string",
+                "card": "string",
+                "sex": "string",
+                "age": 0,
+                "join_time": 0,
+                "last_sent_time": 0,
+                "level": 0,
+                "qq_level": 0,
+                "role": "string",
+                "title": "string",
+                "area": "string",
+                "unfriendly": true,
+                "title_expire_time": 0,
+                "card_changeable": true,
+                "shut_up_timestamp": 0,
+                "is_robot": true,
+                "qage": "string"
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_GROUP_MEMBER_LIST = "napcat_get_group_member_list"
-        '''获取群成员列表'''
+        '''获取群成员列表
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            no_cache (Optional[bool]): 是否不缓存
+            raw (Optional[dict]): 原始请求体 
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": [
+                {
+                    "group_id": 0,
+                    "user_id": 0,
+                    "nickname": "string",
+                    "card": "string",
+                    "sex": "string",
+                    "age": 0,
+                    "join_time": 0,
+                    "last_sent_time": 0,
+                    "level": 0,
+                    "qq_level": 0,
+                    "role": "string",
+                    "title": "string",
+                    "area": "string",
+                    "unfriendly": true,
+                    "title_expire_time": 0,
+                    "card_changeable": true,
+                    "shut_up_timestamp": 0,
+                    "is_robot": true,
+                    "qage": "string"
+                }
+            ],
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_GROUP_HONOR_INFO = "napcat_get_group_honor_info"
-        '''获取群荣誉'''
+        '''获取群荣誉
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            type (Optional[str]): 看详情
+            raw (Optional[dict]): 原始请求体 
+        
+        Returns:
+            dict:{
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "group_id": "string",
+                "current_talkative": {
+                    "user_id": 0,
+                    "nickname": "string",
+                    "avatar": 0,
+                    "description": "string"
+                },
+                "talkative_list": [
+                    {
+                        "user_id": 0,
+                        "nickname": "string",
+                        "avatar": 0,
+                        "description": "string"
+                    }
+                ],
+                "performer_list": [
+                    {
+                        "user_id": 0,
+                        "nickname": "string",
+                        "avatar": 0,
+                        "description": "string"
+                    }
+                ],
+                "legend_list": [
+                    {
+                        "user_id": 0,
+                        "nickname": "string",
+                        "avatar": 0,
+                        "description": "string"
+                    }
+                ],
+                "emotion_list": [
+                    {
+                        "user_id": 0,
+                        "nickname": "string",
+                        "avatar": 0,
+                        "description": "string"
+                    }
+                ],
+                "strong_newbie_list": [
+                    {
+                        "user_id": 0,
+                        "nickname": "string",
+                        "avatar": 0,
+                        "description": "string"
+                    }
+                ]
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_GROUP_INFO_EX = "napcat_get_group_info_ex"
-        '''获取群信息ex'''   
+        '''获取群信息ex
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            raw (Optional[dict]): 原始请求体 
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "groupCode": "790514019",
+                "resultCode": 0,
+                "extInfo": {
+                    "groupInfoExtSeq": 1,
+                    "reserve": 0,
+                    "luckyWordId": "0",
+                    "lightCharNum": 0,
+                    "luckyWord": "",
+                    "starId": 0,
+                    "essentialMsgSwitch": 0,
+                    "todoSeq": 0,
+                    "blacklistExpireTime": 0,
+                    "isLimitGroupRtc": 0,
+                    "companyId": 0,
+                    "hasGroupCustomPortrait": 1,
+                    "bindGuildId": "0",
+                    "groupOwnerId": {
+                        "memberUin": "1129317309",
+                        "memberUid": "u_4_QA-QaFryh-Ocgsv4_8EQ",
+                        "memberQid": ""
+                    },
+                    "essentialMsgPrivilege": 0,
+                    "msgEventSeq": "0",
+                    "inviteRobotSwitch": 0,
+                    "gangUpId": "0",
+                    "qqMusicMedalSwitch": 0,
+                    "showPlayTogetherSwitch": 0,
+                    "groupFlagPro1": "0",
+                    "groupBindGuildIds": {
+                        "guildIds": []
+                    },
+                    "viewedMsgDisappearTime": "0",
+                    "groupExtFlameData": {
+                        "switchState": 0,
+                        "state": 0,
+                        "dayNums": [],
+                        "version": 0,
+                        "updateTime": "0",
+                        "isDisplayDayNum": false
+                    },
+                    "groupBindGuildSwitch": 0,
+                    "groupAioBindGuildId": "0",
+                    "groupExcludeGuildIds": {
+                        "guildIds": []
+                    },
+                    "fullGroupExpansionSwitch": 0,
+                    "fullGroupExpansionSeq": "0",
+                    "inviteRobotMemberSwitch": 0,
+                    "inviteRobotMemberExamine": 0,
+                    "groupSquareSwitch": 0
+                }
+            },
+            "message": "",
+            "wording": "",
+            "echo": null
+        }      
+        '''   
         GET_GROUP_AT_ALL_REMAIN = "napcat_get_group_at_all_remain"
-        '''获取群 @全体成员 剩余次数'''
+        '''获取群 @全体成员 剩余次数
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            raw (Optional[dict]): 原始请求体 
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "can_at_all": true,
+                "remain_at_all_count_for_group": 0,
+                "remain_at_all_count_for_uin": 0
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_GROUP_SHUT_LIST = "napcat_get_group_shut_list"
-        '''获取群禁言列表'''
+        '''获取群禁言列表
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            raw (Optional[dict]): 原始请求体 
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": [
+                {
+                    "uid": "string",
+                    "qid": "string",
+                    "uin": "string",
+                    "nick": "string",
+                    "remark": "string",
+                    "cardType": 0,
+                    "cardName": "string",
+                    "role": 0,
+                    "avatarPath": "string",
+                    "shutUpTime": 0,
+                    "isDelete": true,
+                    "isSpecialConcerned": true,
+                    "isSpecialShield": true,
+                    "isRobot": true,
+                    "groupHonor": {},
+                    "memberRealLevel": 0,
+                    "memberLevel": 0,
+                    "globalGroupLevel": 0,
+                    "globalGroupPoint": 0,
+                    "memberTitleId": 0,
+                    "memberSpecialTitle": "string",
+                    "specialTitleExpireTime": "string",
+                    "userShowFlag": 0,
+                    "userShowFlagNew": 0,
+                    "richFlag": 0,
+                    "mssVipType": 0,
+                    "bigClubLevel": 0,
+                    "bigClubFlag": 0,
+                    "autoRemark": "string",
+                    "creditLevel": 0,
+                    "joinTime": 0,
+                    "lastSpeakTime": 0,
+                    "memberFlag": 0,
+                    "memberFlagExt": 0,
+                    "memberMobileFlag": 0,
+                    "memberFlagExt2": 0,
+                    "isSpecialShielded": true,
+                    "cardNameId": 0
+                }
+            ],
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_GROUP_IGNORED_NOTIFIES = "napcat_get_group_ignored_notifies"
-        '''获取群过滤系统消息'''
+        '''获取群过滤系统消息
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "InvitedRequest": [
+                    {
+                        "request_id": 0,
+                        "invitor_uin": 0,
+                        "invitor_nick": "string",
+                        "group_id": 0,
+                        "message": "string",
+                        "group_name": "string",
+                        "checked": true,
+                        "actor": 0,
+                        "requester_nick": "string"
+                    }
+                ],
+                "join_requests": [
+                    {
+                        "request_id": 0,
+                        "invitor_uin": 0,
+                        "invitor_nick": "string",
+                        "group_id": 0,
+                        "message": "string",
+                        "group_name": "string",
+                        "checked": true,
+                        "actor": 0,
+                        "requester_nick": "string"
+                    }
+                ]
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_GROUP_SIGN = "napcat_set_group_sign"
-        '''群打卡'''
+        '''群打卡
+        
+        Args:
+            group_id (Optional[str|int]): 群号(必需)
+            raw (Optional[dict]): 原始请求体 
 
+        Returns:
+            dict: {}
+        '''
 
+    class FILE(Enum):
+        ...