rustymilky 0.1.0

#![allow(dead_code)]

// Generated from Milky 1.2 (1.2.2)
use serde::{Deserialize, Deserializer, Serialize, Serializer, de::DeserializeOwned};

pub const MILKY_VERSION: &str = "1.2";
pub const MILKY_PACKAGE_VERSION: &str = "1.2.2";

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(bound(serialize = "T: Serialize", deserialize = "T: Deserialize<'de>",))]
pub struct ApiGeneralResponse<T> {
  #[serde(rename = "status")]
  pub status: String,
  #[serde(rename = "retcode")]
  pub retcode: i32,
  #[serde(rename = "data", default, skip_serializing_if = "Option::is_none")]
  pub data: Option<T>,
  #[serde(rename = "message", default, skip_serializing_if = "Option::is_none")]
  pub message: Option<String>,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct ApiEmptyStruct {}
impl From<()> for ApiEmptyStruct {
  fn from(_: ()) -> Self {
    Self {}
  }
}

// ####################################
// Common Structs
// ####################################

/// 事件
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "event_type")]
pub enum Event {
  /// 机器人离线事件
  #[serde(rename = "bot_offline")]
  BotOffline {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 机器人离线事件数据
    #[serde(rename = "data")]
    data: EventBotOfflineData,
  },

  /// 消息接收事件
  #[serde(rename = "message_receive")]
  MessageReceive {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 消息接收事件数据
    #[serde(rename = "data")]
    data: IncomingMessage,
  },

  /// 消息撤回事件
  #[serde(rename = "message_recall")]
  MessageRecall {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 消息撤回事件数据
    #[serde(rename = "data")]
    data: EventMessageRecallData,
  },

  /// 会话置顶变更事件
  #[serde(rename = "peer_pin_change")]
  PeerPinChange {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 会话置顶变更事件数据
    #[serde(rename = "data")]
    data: EventPeerPinChangeData,
  },

  /// 好友请求事件
  #[serde(rename = "friend_request")]
  FriendRequest {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 好友请求事件数据
    #[serde(rename = "data")]
    data: EventFriendRequestData,
  },

  /// 入群请求事件
  #[serde(rename = "group_join_request")]
  GroupJoinRequest {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 入群请求事件数据
    #[serde(rename = "data")]
    data: EventGroupJoinRequestData,
  },

  /// 群成员邀请他人入群请求事件
  #[serde(rename = "group_invited_join_request")]
  GroupInvitedJoinRequest {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群成员邀请他人入群请求事件数据
    #[serde(rename = "data")]
    data: EventGroupInvitedJoinRequestData,
  },

  /// 他人邀请自身入群事件
  #[serde(rename = "group_invitation")]
  GroupInvitation {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 他人邀请自身入群事件数据
    #[serde(rename = "data")]
    data: EventGroupInvitationData,
  },

  /// 好友戳一戳事件
  #[serde(rename = "friend_nudge")]
  FriendNudge {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 好友戳一戳事件数据
    #[serde(rename = "data")]
    data: EventFriendNudgeData,
  },

  /// 好友文件上传事件
  #[serde(rename = "friend_file_upload")]
  FriendFileUpload {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 好友文件上传事件数据
    #[serde(rename = "data")]
    data: EventFriendFileUploadData,
  },

  /// 群管理员变更事件
  #[serde(rename = "group_admin_change")]
  GroupAdminChange {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群管理员变更事件数据
    #[serde(rename = "data")]
    data: EventGroupAdminChangeData,
  },

  /// 群精华消息变更事件
  #[serde(rename = "group_essence_message_change")]
  GroupEssenceMessageChange {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群精华消息变更事件数据
    #[serde(rename = "data")]
    data: EventGroupEssenceMessageChangeData,
  },

  /// 群成员增加事件
  #[serde(rename = "group_member_increase")]
  GroupMemberIncrease {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群成员增加事件数据
    #[serde(rename = "data")]
    data: EventGroupMemberIncreaseData,
  },

  /// 群成员减少事件
  #[serde(rename = "group_member_decrease")]
  GroupMemberDecrease {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群成员减少事件数据
    #[serde(rename = "data")]
    data: EventGroupMemberDecreaseData,
  },

  /// 群名称变更事件
  #[serde(rename = "group_name_change")]
  GroupNameChange {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群名称变更事件数据
    #[serde(rename = "data")]
    data: EventGroupNameChangeData,
  },

  /// 群消息表情回应事件
  #[serde(rename = "group_message_reaction")]
  GroupMessageReaction {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群消息表情回应事件数据
    #[serde(rename = "data")]
    data: EventGroupMessageReactionData,
  },

  /// 群禁言事件
  #[serde(rename = "group_mute")]
  GroupMute {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群禁言事件数据
    #[serde(rename = "data")]
    data: EventGroupMuteData,
  },

  /// 群全体禁言事件
  #[serde(rename = "group_whole_mute")]
  GroupWholeMute {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群全体禁言事件数据
    #[serde(rename = "data")]
    data: EventGroupWholeMuteData,
  },

  /// 群戳一戳事件
  #[serde(rename = "group_nudge")]
  GroupNudge {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群戳一戳事件数据
    #[serde(rename = "data")]
    data: EventGroupNudgeData,
  },

  /// 群文件上传事件
  #[serde(rename = "group_file_upload")]
  GroupFileUpload {
    /// 事件 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 机器人 QQ 号
    #[serde(rename = "self_id")]
    self_id: i64,
    /// 群文件上传事件数据
    #[serde(rename = "data")]
    data: EventGroupFileUploadData,
  },
}

/// 机器人离线事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventBotOfflineData {
  /// 下线原因
  #[serde(rename = "reason")]
  pub reason: String,
}

/// 消息撤回事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventMessageRecallData {
  /// 消息场景
  #[serde(rename = "message_scene")]
  pub message_scene: String,
  /// 好友 QQ 号或群号
  #[serde(rename = "peer_id")]
  pub peer_id: i64,
  /// 消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
  /// 被撤回的消息的发送者 QQ 号
  #[serde(rename = "sender_id")]
  pub sender_id: i64,
  /// 操作者 QQ 号
  #[serde(rename = "operator_id")]
  pub operator_id: i64,
  /// 撤回提示的后缀文本
  #[serde(rename = "display_suffix")]
  pub display_suffix: String,
}

/// 会话置顶变更事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventPeerPinChangeData {
  /// 发生改变的会话的消息场景
  #[serde(rename = "message_scene")]
  pub message_scene: String,
  /// 发生改变的好友 QQ 号或群号
  #[serde(rename = "peer_id")]
  pub peer_id: i64,
  /// 是否被置顶, `false` 表示取消置顶
  #[serde(rename = "is_pinned")]
  pub is_pinned: bool,
}

/// 好友请求事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventFriendRequestData {
  /// 申请好友的用户 QQ 号
  #[serde(rename = "initiator_id")]
  pub initiator_id: i64,
  /// 用户 UID
  #[serde(rename = "initiator_uid")]
  pub initiator_uid: String,
  /// 申请附加信息
  #[serde(rename = "comment")]
  pub comment: String,
  /// 申请来源
  #[serde(rename = "via")]
  pub via: String,
}

/// 入群请求事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupJoinRequestData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 请求对应的通知序列号
  #[serde(rename = "notification_seq")]
  pub notification_seq: i64,
  /// 请求是否被过滤（发起自风险账户）
  #[serde(rename = "is_filtered")]
  pub is_filtered: bool,
  /// 申请入群的用户 QQ 号
  #[serde(rename = "initiator_id")]
  pub initiator_id: i64,
  /// 申请附加信息
  #[serde(rename = "comment")]
  pub comment: String,
}

/// 群成员邀请他人入群请求事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupInvitedJoinRequestData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 请求对应的通知序列号
  #[serde(rename = "notification_seq")]
  pub notification_seq: i64,
  /// 邀请者 QQ 号
  #[serde(rename = "initiator_id")]
  pub initiator_id: i64,
  /// 被邀请者 QQ 号
  #[serde(rename = "target_user_id")]
  pub target_user_id: i64,
}

/// 他人邀请自身入群事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupInvitationData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 邀请序列号
  #[serde(rename = "invitation_seq")]
  pub invitation_seq: i64,
  /// 邀请者 QQ 号
  #[serde(rename = "initiator_id")]
  pub initiator_id: i64,
  /// 来源群号，如果是通过 QQ 群邀请
  #[serde(
    rename = "source_group_id",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub source_group_id: Option<i64>,
}

/// 好友戳一戳事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventFriendNudgeData {
  /// 好友 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 是否是自己发送的戳一戳
  #[serde(rename = "is_self_send")]
  pub is_self_send: bool,
  /// 是否是自己接收的戳一戳
  #[serde(rename = "is_self_receive")]
  pub is_self_receive: bool,
  /// 戳一戳提示的动作文本
  #[serde(rename = "display_action")]
  pub display_action: String,
  /// 戳一戳提示的后缀文本
  #[serde(rename = "display_suffix")]
  pub display_suffix: String,
  /// 戳一戳提示的动作图片 URL，用于取代动作提示文本
  #[serde(rename = "display_action_img_url")]
  pub display_action_img_url: String,
}

/// 好友文件上传事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventFriendFileUploadData {
  /// 好友 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
  /// 文件名称
  #[serde(rename = "file_name")]
  pub file_name: String,
  /// 文件大小（字节）
  #[serde(rename = "file_size")]
  pub file_size: i64,
  /// 文件的 TriSHA1 哈希值
  #[serde(rename = "file_hash")]
  pub file_hash: String,
  /// 是否是自己发送的文件
  #[serde(rename = "is_self")]
  pub is_self: bool,
}

/// 群管理员变更事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupAdminChangeData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 发生变更的用户 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 操作者 QQ 号
  #[serde(rename = "operator_id")]
  pub operator_id: i64,
  /// 是否被设置为管理员，`false` 表示被取消管理员
  #[serde(rename = "is_set")]
  pub is_set: bool,
}

/// 群精华消息变更事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupEssenceMessageChangeData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 发生变更的消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
  /// 操作者 QQ 号
  #[serde(rename = "operator_id")]
  pub operator_id: i64,
  /// 是否被设置为精华，`false` 表示被取消精华
  #[serde(rename = "is_set")]
  pub is_set: bool,
}

/// 群成员增加事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupMemberIncreaseData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 发生变更的用户 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 管理员 QQ 号，如果是管理员同意入群
  #[serde(
    rename = "operator_id",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub operator_id: Option<i64>,
  /// 邀请者 QQ 号，如果是邀请入群
  #[serde(
    rename = "invitor_id",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub invitor_id: Option<i64>,
}

/// 群成员减少事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupMemberDecreaseData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 发生变更的用户 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 管理员 QQ 号，如果是管理员踢出
  #[serde(
    rename = "operator_id",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub operator_id: Option<i64>,
}

/// 群名称变更事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupNameChangeData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 新的群名称
  #[serde(rename = "new_group_name")]
  pub new_group_name: String,
  /// 操作者 QQ 号
  #[serde(rename = "operator_id")]
  pub operator_id: i64,
}

/// 群消息表情回应事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupMessageReactionData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 发送回应者 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
  /// 表情 ID
  #[serde(rename = "face_id")]
  pub face_id: String,
  /// 收到的回应类型
  #[serde(rename = "reaction_type")]
  pub reaction_type: String,
  /// 是否为添加，`false` 表示取消回应
  #[serde(rename = "is_add")]
  pub is_add: bool,
}

/// 群禁言事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupMuteData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 发生变更的用户 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 操作者 QQ 号
  #[serde(rename = "operator_id")]
  pub operator_id: i64,
  /// 禁言时长（秒），为 0 表示取消禁言
  #[serde(rename = "duration")]
  pub duration: i32,
}

/// 群全体禁言事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupWholeMuteData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 操作者 QQ 号
  #[serde(rename = "operator_id")]
  pub operator_id: i64,
  /// 是否全员禁言，`false` 表示取消全员禁言
  #[serde(rename = "is_mute")]
  pub is_mute: bool,
}

/// 群戳一戳事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupNudgeData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 发送者 QQ 号
  #[serde(rename = "sender_id")]
  pub sender_id: i64,
  /// 接收者 QQ 号
  #[serde(rename = "receiver_id")]
  pub receiver_id: i64,
  /// 戳一戳提示的动作文本
  #[serde(rename = "display_action")]
  pub display_action: String,
  /// 戳一戳提示的后缀文本
  #[serde(rename = "display_suffix")]
  pub display_suffix: String,
  /// 戳一戳提示的动作图片 URL，用于取代动作提示文本
  #[serde(rename = "display_action_img_url")]
  pub display_action_img_url: String,
}

/// 群文件上传事件数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGroupFileUploadData {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 发送者 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
  /// 文件名称
  #[serde(rename = "file_name")]
  pub file_name: String,
  /// 文件大小（字节）
  #[serde(rename = "file_size")]
  pub file_size: i64,
}

/// 好友实体
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FriendEntity {
  /// 用户 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 用户昵称
  #[serde(rename = "nickname")]
  pub nickname: String,
  /// 用户性别
  #[serde(rename = "sex")]
  pub sex: String,
  /// 用户 QID
  #[serde(rename = "qid")]
  pub qid: String,
  /// 好友备注
  #[serde(rename = "remark")]
  pub remark: String,
  /// 好友分组
  #[serde(rename = "category")]
  pub category: FriendCategoryEntity,
}

/// 好友分组实体
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FriendCategoryEntity {
  /// 好友分组 ID
  #[serde(rename = "category_id")]
  pub category_id: i32,
  /// 好友分组名称
  #[serde(rename = "category_name")]
  pub category_name: String,
}

/// 群实体
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GroupEntity {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 群名称
  #[serde(rename = "group_name")]
  pub group_name: String,
  /// 群成员数量
  #[serde(rename = "member_count")]
  pub member_count: i32,
  /// 群容量
  #[serde(rename = "max_member_count")]
  pub max_member_count: i32,
  /// 群备注
  #[serde(rename = "remark")]
  pub remark: String,
  /// 群创建时间，Unix 时间戳（秒）
  #[serde(rename = "created_time")]
  pub created_time: i64,
  /// 群简介
  #[serde(rename = "description")]
  pub description: String,
  /// 加群验证问题
  #[serde(rename = "question")]
  pub question: String,
  /// 群公告预览
  #[serde(rename = "announcement")]
  pub announcement: String,
}

/// 群成员实体
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GroupMemberEntity {
  /// 用户 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 用户昵称
  #[serde(rename = "nickname")]
  pub nickname: String,
  /// 用户性别
  #[serde(rename = "sex")]
  pub sex: String,
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 成员备注
  #[serde(rename = "card")]
  pub card: String,
  /// 专属头衔
  #[serde(rename = "title")]
  pub title: String,
  /// 群等级，注意和 QQ 等级区分
  #[serde(rename = "level")]
  pub level: i32,
  /// 权限等级
  #[serde(rename = "role")]
  pub role: String,
  /// 入群时间，Unix 时间戳（秒）
  #[serde(rename = "join_time")]
  pub join_time: i64,
  /// 最后发言时间，Unix 时间戳（秒）
  #[serde(rename = "last_sent_time")]
  pub last_sent_time: i64,
  /// 禁言结束时间，Unix 时间戳（秒）
  #[serde(
    rename = "shut_up_end_time",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub shut_up_end_time: Option<i64>,
}

/// 群公告实体
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GroupAnnouncementEntity {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 公告 ID
  #[serde(rename = "announcement_id")]
  pub announcement_id: String,
  /// 发送者 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// Unix 时间戳（秒）
  #[serde(rename = "time")]
  pub time: i64,
  /// 公告内容
  #[serde(rename = "content")]
  pub content: String,
  /// 公告图片 URL
  #[serde(rename = "image_url", default, skip_serializing_if = "Option::is_none")]
  pub image_url: Option<String>,
}

/// 群文件实体
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GroupFileEntity {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
  /// 文件名称
  #[serde(rename = "file_name")]
  pub file_name: String,
  /// 父文件夹 ID
  #[serde(rename = "parent_folder_id")]
  pub parent_folder_id: String,
  /// 文件大小（字节）
  #[serde(rename = "file_size")]
  pub file_size: i64,
  /// 上传时的 Unix 时间戳（秒）
  #[serde(rename = "uploaded_time")]
  pub uploaded_time: i64,
  /// 过期时的 Unix 时间戳（秒）
  #[serde(
    rename = "expire_time",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub expire_time: Option<i64>,
  /// 上传者 QQ 号
  #[serde(rename = "uploader_id")]
  pub uploader_id: i64,
  /// 下载次数
  #[serde(rename = "downloaded_times")]
  pub downloaded_times: i32,
}

/// 群文件夹实体
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GroupFolderEntity {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 文件夹 ID
  #[serde(rename = "folder_id")]
  pub folder_id: String,
  /// 父文件夹 ID
  #[serde(rename = "parent_folder_id")]
  pub parent_folder_id: String,
  /// 文件夹名称
  #[serde(rename = "folder_name")]
  pub folder_name: String,
  /// 创建时的 Unix 时间戳（秒）
  #[serde(rename = "created_time")]
  pub created_time: i64,
  /// 最后修改时的 Unix 时间戳（秒）
  #[serde(rename = "last_modified_time")]
  pub last_modified_time: i64,
  /// 创建者 QQ 号
  #[serde(rename = "creator_id")]
  pub creator_id: i64,
  /// 文件数量
  #[serde(rename = "file_count")]
  pub file_count: i32,
}

/// 好友请求实体
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FriendRequest {
  /// 请求发起时的 Unix 时间戳（秒）
  #[serde(rename = "time")]
  pub time: i64,
  /// 请求发起者 QQ 号
  #[serde(rename = "initiator_id")]
  pub initiator_id: i64,
  /// 请求发起者 UID
  #[serde(rename = "initiator_uid")]
  pub initiator_uid: String,
  /// 目标用户 QQ 号
  #[serde(rename = "target_user_id")]
  pub target_user_id: i64,
  /// 目标用户 UID
  #[serde(rename = "target_user_uid")]
  pub target_user_uid: String,
  /// 请求状态
  #[serde(rename = "state")]
  pub state: String,
  /// 申请附加信息
  #[serde(rename = "comment")]
  pub comment: String,
  /// 申请来源
  #[serde(rename = "via")]
  pub via: String,
  /// 请求是否被过滤（发起自风险账户）
  #[serde(rename = "is_filtered")]
  pub is_filtered: bool,
}

/// 群通知实体
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum GroupNotification {
  /// 用户入群请求
  #[serde(rename = "join_request")]
  JoinRequest {
    /// 群号
    #[serde(rename = "group_id")]
    group_id: i64,
    /// 通知序列号
    #[serde(rename = "notification_seq")]
    notification_seq: i64,
    /// 请求是否被过滤（发起自风险账户）
    #[serde(rename = "is_filtered")]
    is_filtered: bool,
    /// 发起者 QQ 号
    #[serde(rename = "initiator_id")]
    initiator_id: i64,
    /// 请求状态
    #[serde(rename = "state")]
    state: String,
    /// 处理请求的管理员 QQ 号
    #[serde(
      rename = "operator_id",
      default,
      skip_serializing_if = "Option::is_none"
    )]
    operator_id: Option<i64>,
    /// 入群请求附加信息
    #[serde(rename = "comment")]
    comment: String,
  },

  /// 群管理员变更通知
  #[serde(rename = "admin_change")]
  AdminChange {
    /// 群号
    #[serde(rename = "group_id")]
    group_id: i64,
    /// 通知序列号
    #[serde(rename = "notification_seq")]
    notification_seq: i64,
    /// 被设置/取消用户 QQ 号
    #[serde(rename = "target_user_id")]
    target_user_id: i64,
    /// 是否被设置为管理员，`false` 表示被取消管理员
    #[serde(rename = "is_set")]
    is_set: bool,
    /// 操作者（群主）QQ 号
    #[serde(rename = "operator_id")]
    operator_id: i64,
  },

  /// 群成员被移除通知
  #[serde(rename = "kick")]
  Kick {
    /// 群号
    #[serde(rename = "group_id")]
    group_id: i64,
    /// 通知序列号
    #[serde(rename = "notification_seq")]
    notification_seq: i64,
    /// 被移除用户 QQ 号
    #[serde(rename = "target_user_id")]
    target_user_id: i64,
    /// 移除用户的管理员 QQ 号
    #[serde(rename = "operator_id")]
    operator_id: i64,
  },

  /// 群成员退群通知
  #[serde(rename = "quit")]
  Quit {
    /// 群号
    #[serde(rename = "group_id")]
    group_id: i64,
    /// 通知序列号
    #[serde(rename = "notification_seq")]
    notification_seq: i64,
    /// 退群用户 QQ 号
    #[serde(rename = "target_user_id")]
    target_user_id: i64,
  },

  /// 群成员邀请他人入群请求
  #[serde(rename = "invited_join_request")]
  InvitedJoinRequest {
    /// 群号
    #[serde(rename = "group_id")]
    group_id: i64,
    /// 通知序列号
    #[serde(rename = "notification_seq")]
    notification_seq: i64,
    /// 邀请者 QQ 号
    #[serde(rename = "initiator_id")]
    initiator_id: i64,
    /// 被邀请用户 QQ 号
    #[serde(rename = "target_user_id")]
    target_user_id: i64,
    /// 请求状态
    #[serde(rename = "state")]
    state: String,
    /// 处理请求的管理员 QQ 号
    #[serde(
      rename = "operator_id",
      default,
      skip_serializing_if = "Option::is_none"
    )]
    operator_id: Option<i64>,
  },
}

/// 接收消息
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "message_scene")]
pub enum IncomingMessage {
  /// 好友消息
  #[serde(rename = "friend")]
  Friend {
    /// 好友 QQ 号或群号
    #[serde(rename = "peer_id")]
    peer_id: i64,
    /// 消息序列号
    #[serde(rename = "message_seq")]
    message_seq: i64,
    /// 发送者 QQ 号
    #[serde(rename = "sender_id")]
    sender_id: i64,
    /// 消息 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 消息段列表
    #[serde(
      rename = "segments",
      deserialize_with = "deserialize_incoming_segment_list"
    )]
    segments: Vec<IncomingSegment>,
    /// 好友信息
    #[serde(rename = "friend")]
    friend: FriendEntity,
  },

  /// 群消息
  #[serde(rename = "group")]
  Group {
    /// 好友 QQ 号或群号
    #[serde(rename = "peer_id")]
    peer_id: i64,
    /// 消息序列号
    #[serde(rename = "message_seq")]
    message_seq: i64,
    /// 发送者 QQ 号
    #[serde(rename = "sender_id")]
    sender_id: i64,
    /// 消息 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 消息段列表
    #[serde(
      rename = "segments",
      deserialize_with = "deserialize_incoming_segment_list"
    )]
    segments: Vec<IncomingSegment>,
    /// 群信息
    #[serde(rename = "group")]
    group: GroupEntity,
    /// 群成员信息
    #[serde(rename = "group_member")]
    group_member: GroupMemberEntity,
  },

  /// 临时会话消息
  #[serde(rename = "temp")]
  Temp {
    /// 好友 QQ 号或群号
    #[serde(rename = "peer_id")]
    peer_id: i64,
    /// 消息序列号
    #[serde(rename = "message_seq")]
    message_seq: i64,
    /// 发送者 QQ 号
    #[serde(rename = "sender_id")]
    sender_id: i64,
    /// 消息 Unix 时间戳（秒）
    #[serde(rename = "time")]
    time: i64,
    /// 消息段列表
    #[serde(
      rename = "segments",
      deserialize_with = "deserialize_incoming_segment_list"
    )]
    segments: Vec<IncomingSegment>,
    /// 临时会话发送者的所在的群信息
    #[serde(rename = "group", default, skip_serializing_if = "Option::is_none")]
    group: Option<GroupEntity>,
  },
}

/// 接收转发消息
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingForwardedMessage {
  /// 消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
  /// 发送者名称
  #[serde(rename = "sender_name")]
  pub sender_name: String,
  /// 发送者头像 URL
  #[serde(rename = "avatar_url")]
  pub avatar_url: String,
  /// 消息 Unix 时间戳（秒）
  #[serde(rename = "time")]
  pub time: i64,
  /// 消息段列表
  #[serde(
    rename = "segments",
    deserialize_with = "deserialize_incoming_segment_list"
  )]
  pub segments: Vec<IncomingSegment>,
}

/// 群精华消息
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GroupEssenceMessage {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
  /// 消息发送时的 Unix 时间戳（秒）
  #[serde(rename = "message_time")]
  pub message_time: i64,
  /// 发送者 QQ 号
  #[serde(rename = "sender_id")]
  pub sender_id: i64,
  /// 发送者名称
  #[serde(rename = "sender_name")]
  pub sender_name: String,
  /// 设置精华的操作者 QQ 号
  #[serde(rename = "operator_id")]
  pub operator_id: i64,
  /// 设置精华的操作者名称
  #[serde(rename = "operator_name")]
  pub operator_name: String,
  /// 消息被设置精华时的 Unix 时间戳（秒）
  #[serde(rename = "operation_time")]
  pub operation_time: i64,
  /// 消息段列表
  #[serde(
    rename = "segments",
    deserialize_with = "deserialize_incoming_segment_list"
  )]
  pub segments: Vec<IncomingSegment>,
}

/// 接收消息段
#[derive(Debug, Clone, PartialEq)]
pub enum IncomingSegment {
  /// 文本消息段
  Text(String),
  /// 提及消息段
  Mention(IncomingSegmentMentionData),
  /// 提及全体消息段
  MentionAll,
  /// 表情消息段
  Face(IncomingSegmentFaceData),
  /// 回复消息段
  Reply(IncomingSegmentReplyData),
  /// 图片消息段
  Image(IncomingSegmentImageData),
  /// 语音消息段
  Record(IncomingSegmentRecordData),
  /// 视频消息段
  Video(IncomingSegmentVideoData),
  /// 文件消息段
  File(IncomingSegmentFileData),
  /// 合并转发消息段
  Forward(IncomingSegmentForwardData),
  /// 市场表情消息段
  MarketFace(IncomingSegmentMarketFaceData),
  /// 小程序消息段
  LightApp(IncomingSegmentLightAppData),
  /// XML 消息段
  Xml(IncomingSegmentXmlData),
}

impl Serialize for IncomingSegment {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: Serializer,
  {
    match self {
      IncomingSegment::Text(text) => serialize_segment_with_data(
        serializer,
        "text",
        &IncomingSegmentTextData { text: text.clone() },
      ),
      IncomingSegment::Mention(data) => serialize_segment_with_data(serializer, "mention", data),
      IncomingSegment::MentionAll => {
        serialize_segment_with_data(serializer, "mention_all", &IncomingSegmentMentionAllData {})
      }
      IncomingSegment::Face(data) => serialize_segment_with_data(serializer, "face", data),
      IncomingSegment::Reply(data) => serialize_segment_with_data(serializer, "reply", data),
      IncomingSegment::Image(data) => serialize_segment_with_data(serializer, "image", data),
      IncomingSegment::Record(data) => serialize_segment_with_data(serializer, "record", data),
      IncomingSegment::Video(data) => serialize_segment_with_data(serializer, "video", data),
      IncomingSegment::File(data) => serialize_segment_with_data(serializer, "file", data),
      IncomingSegment::Forward(data) => serialize_segment_with_data(serializer, "forward", data),
      IncomingSegment::MarketFace(data) => {
        serialize_segment_with_data(serializer, "market_face", data)
      }
      IncomingSegment::LightApp(data) => serialize_segment_with_data(serializer, "light_app", data),
      IncomingSegment::Xml(data) => serialize_segment_with_data(serializer, "xml", data),
    }
  }
}

impl<'de> Deserialize<'de> for IncomingSegment {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: Deserializer<'de>,
  {
    let value = serde_json::Value::deserialize(deserializer)?;
    match deserialize_segment_type::<D::Error>(&value)? {
      "text" => Ok(Self::Text(
        deserialize_segment_data::<D::Error, IncomingSegmentTextData>(&value)?.text,
      )),
      "mention" => Ok(Self::Mention(deserialize_segment_data(&value)?)),
      "mention_all" => {
        let _: IncomingSegmentMentionAllData = deserialize_segment_data(&value)?;
        Ok(Self::MentionAll)
      }
      "face" => Ok(Self::Face(deserialize_segment_data(&value)?)),
      "reply" => Ok(Self::Reply(deserialize_segment_data(&value)?)),
      "image" => Ok(Self::Image(deserialize_segment_data(&value)?)),
      "record" => Ok(Self::Record(deserialize_segment_data(&value)?)),
      "video" => Ok(Self::Video(deserialize_segment_data(&value)?)),
      "file" => Ok(Self::File(deserialize_segment_data(&value)?)),
      "forward" => Ok(Self::Forward(deserialize_segment_data(&value)?)),
      "market_face" => Ok(Self::MarketFace(deserialize_segment_data(&value)?)),
      "light_app" => Ok(Self::LightApp(deserialize_segment_data(&value)?)),
      "xml" => Ok(Self::Xml(deserialize_segment_data(&value)?)),
      other => Err(serde::de::Error::unknown_variant(
        other,
        &[
          "text",
          "mention",
          "mention_all",
          "face",
          "reply",
          "image",
          "record",
          "video",
          "file",
          "forward",
          "market_face",
          "light_app",
          "xml",
        ],
      )),
    }
  }
}

/// 文本消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentTextData {
  /// 文本内容
  #[serde(rename = "text")]
  pub text: String,
}

/// 提及消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentMentionData {
  /// 提及的 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 去掉 `@` 前缀的提及的名称
  #[serde(rename = "name")]
  pub name: String,
}

/// 提及全体消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentMentionAllData {}

/// 表情消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentFaceData {
  /// 表情 ID
  #[serde(rename = "face_id")]
  pub face_id: String,
  /// 是否为超级表情
  #[serde(rename = "is_large")]
  pub is_large: bool,
}

/// 回复消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentReplyData {
  /// 被引用的消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
  /// 被引用的消息发送者 QQ 号
  #[serde(rename = "sender_id")]
  pub sender_id: i64,
  /// 被引用的消息发送者名称，仅在合并转发中能够获取
  #[serde(
    rename = "sender_name",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub sender_name: Option<String>,
  /// 被引用的消息的 Unix 时间戳（秒）
  #[serde(rename = "time")]
  pub time: i64,
  /// 被引用的消息内容
  #[serde(
    rename = "segments",
    deserialize_with = "deserialize_incoming_segment_list"
  )]
  pub segments: Vec<IncomingSegment>,
}

/// 图片消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentImageData {
  /// 资源 ID
  #[serde(rename = "resource_id")]
  pub resource_id: String,
  /// 临时 URL
  #[serde(rename = "temp_url")]
  pub temp_url: String,
  /// 图片宽度
  #[serde(rename = "width")]
  pub width: i32,
  /// 图片高度
  #[serde(rename = "height")]
  pub height: i32,
  /// 图片预览文本
  #[serde(rename = "summary")]
  pub summary: String,
  /// 图片类型
  #[serde(rename = "sub_type")]
  pub sub_type: String,
}

/// 语音消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentRecordData {
  /// 资源 ID
  #[serde(rename = "resource_id")]
  pub resource_id: String,
  /// 临时 URL
  #[serde(rename = "temp_url")]
  pub temp_url: String,
  /// 语音时长（秒）
  #[serde(rename = "duration")]
  pub duration: i32,
}

/// 视频消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentVideoData {
  /// 资源 ID
  #[serde(rename = "resource_id")]
  pub resource_id: String,
  /// 临时 URL
  #[serde(rename = "temp_url")]
  pub temp_url: String,
  /// 视频宽度
  #[serde(rename = "width")]
  pub width: i32,
  /// 视频高度
  #[serde(rename = "height")]
  pub height: i32,
  /// 视频时长（秒）
  #[serde(rename = "duration")]
  pub duration: i32,
}

/// 文件消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentFileData {
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
  /// 文件名称
  #[serde(rename = "file_name")]
  pub file_name: String,
  /// 文件大小（字节）
  #[serde(rename = "file_size")]
  pub file_size: i64,
  /// 文件的 TriSHA1 哈希值，仅在私聊文件中存在
  #[serde(rename = "file_hash", default, skip_serializing_if = "Option::is_none")]
  pub file_hash: Option<String>,
}

/// 合并转发消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentForwardData {
  /// 合并转发 ID
  #[serde(rename = "forward_id")]
  pub forward_id: String,
  /// 合并转发标题
  #[serde(rename = "title")]
  pub title: String,
  /// 合并转发预览文本
  #[serde(rename = "preview")]
  pub preview: Vec<String>,
  /// 合并转发摘要
  #[serde(rename = "summary")]
  pub summary: String,
}

/// 市场表情消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentMarketFaceData {
  /// 市场表情包 ID
  #[serde(rename = "emoji_package_id")]
  pub emoji_package_id: i32,
  /// 市场表情 ID
  #[serde(rename = "emoji_id")]
  pub emoji_id: String,
  /// 市场表情 Key
  #[serde(rename = "key")]
  pub key: String,
  /// 市场表情预览文本
  #[serde(rename = "summary")]
  pub summary: String,
  /// 市场表情 URL
  #[serde(rename = "url")]
  pub url: String,
}

/// 小程序消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentLightAppData {
  /// 小程序名称
  #[serde(rename = "app_name")]
  pub app_name: String,
  /// 小程序 JSON 数据
  #[serde(rename = "json_payload")]
  pub json_payload: String,
}

/// XML 消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IncomingSegmentXmlData {
  /// 服务 ID
  #[serde(rename = "service_id")]
  pub service_id: i32,
  /// XML 数据
  #[serde(rename = "xml_payload")]
  pub xml_payload: String,
}

/// 发送转发消息
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingForwardedMessage {
  /// 发送者 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 发送者名称
  #[serde(rename = "sender_name")]
  pub sender_name: String,
  /// 消息段列表
  #[serde(
    rename = "segments",
    deserialize_with = "deserialize_drop_bad_outgoing_segment_list"
  )]
  pub segments: Vec<OutgoingSegment>,
}

/// 发送消息段
#[derive(Debug, Clone, PartialEq)]
pub enum OutgoingSegment {
  /// 文本消息段
  Text(String),
  /// 提及消息段
  Mention(i64),
  /// 提及全体消息段
  MentionAll,
  /// 表情消息段
  Face(OutgoingSegmentFaceData),
  /// 回复消息段
  Reply(i64),
  /// 图片消息段
  Image(OutgoingSegmentImageData),
  /// 语音消息段
  Record(String),
  /// 视频消息段
  Video(OutgoingSegmentVideoData),
  /// 合并转发消息段
  Forward(OutgoingSegmentForwardData),
  /// 小程序消息段
  LightApp(String),
}

impl Serialize for OutgoingSegment {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: Serializer,
  {
    match self {
      OutgoingSegment::Text(text) => serialize_segment_with_data(
        serializer,
        "text",
        &OutgoingSegmentTextData { text: text.clone() },
      ),
      OutgoingSegment::Mention(user_id) => serialize_segment_with_data(
        serializer,
        "mention",
        &OutgoingSegmentMentionData { user_id: *user_id },
      ),
      OutgoingSegment::MentionAll => {
        serialize_segment_with_data(serializer, "mention_all", &OutgoingSegmentMentionAllData {})
      }
      OutgoingSegment::Face(data) => serialize_segment_with_data(serializer, "face", data),
      OutgoingSegment::Reply(message_seq) => serialize_segment_with_data(
        serializer,
        "reply",
        &OutgoingSegmentReplyData {
          message_seq: *message_seq,
        },
      ),
      OutgoingSegment::Image(data) => serialize_segment_with_data(serializer, "image", data),
      OutgoingSegment::Record(uri) => serialize_segment_with_data(
        serializer,
        "record",
        &OutgoingSegmentRecordData { uri: uri.clone() },
      ),
      OutgoingSegment::Video(data) => serialize_segment_with_data(serializer, "video", data),
      OutgoingSegment::Forward(data) => serialize_segment_with_data(serializer, "forward", data),
      OutgoingSegment::LightApp(json_payload) => serialize_segment_with_data(
        serializer,
        "light_app",
        &OutgoingSegmentLightAppData {
          json_payload: json_payload.clone(),
        },
      ),
    }
  }
}

impl<'de> Deserialize<'de> for OutgoingSegment {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: Deserializer<'de>,
  {
    let value = serde_json::Value::deserialize(deserializer)?;
    match deserialize_segment_type::<D::Error>(&value)? {
      "text" => Ok(Self::Text(
        deserialize_segment_data::<D::Error, OutgoingSegmentTextData>(&value)?.text,
      )),
      "mention" => Ok(Self::Mention(
        deserialize_segment_data::<D::Error, OutgoingSegmentMentionData>(&value)?.user_id,
      )),
      "mention_all" => {
        let _: OutgoingSegmentMentionAllData = deserialize_segment_data(&value)?;
        Ok(Self::MentionAll)
      }
      "face" => Ok(Self::Face(deserialize_segment_data(&value)?)),
      "reply" => Ok(Self::Reply(
        deserialize_segment_data::<D::Error, OutgoingSegmentReplyData>(&value)?.message_seq,
      )),
      "image" => Ok(Self::Image(deserialize_segment_data(&value)?)),
      "record" => Ok(Self::Record(
        deserialize_segment_data::<D::Error, OutgoingSegmentRecordData>(&value)?.uri,
      )),
      "video" => Ok(Self::Video(deserialize_segment_data(&value)?)),
      "forward" => Ok(Self::Forward(deserialize_segment_data(&value)?)),
      "light_app" => Ok(Self::LightApp(
        deserialize_segment_data::<D::Error, OutgoingSegmentLightAppData>(&value)?.json_payload,
      )),
      other => Err(serde::de::Error::unknown_variant(
        other,
        &[
          "text",
          "mention",
          "mention_all",
          "face",
          "reply",
          "image",
          "record",
          "video",
          "forward",
          "light_app",
        ],
      )),
    }
  }
}

/// 文本消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingSegmentTextData {
  /// 文本内容
  #[serde(rename = "text")]
  pub text: String,
}

/// 提及消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingSegmentMentionData {
  /// 提及的 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
}

/// 提及全体消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingSegmentMentionAllData {}

/// 表情消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingSegmentFaceData {
  /// 表情 ID
  #[serde(rename = "face_id")]
  pub face_id: String,
  /// 是否为超级表情
  #[serde(
    rename = "is_large",
    default = "default_outgoing_segment_face_data_is_large",
    deserialize_with = "deserialize_outgoing_segment_face_data_is_large"
  )]
  pub is_large: bool,
}

/// 回复消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingSegmentReplyData {
  /// 被引用的消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
}

/// 图片消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingSegmentImageData {
  /// 文件 URI，支持 `file://` `http(s)://` `base64://` 三种格式
  #[serde(rename = "uri")]
  pub uri: String,
  /// 图片类型
  #[serde(
    rename = "sub_type",
    default = "default_outgoing_segment_image_data_sub_type",
    deserialize_with = "deserialize_outgoing_segment_image_data_sub_type"
  )]
  pub sub_type: String,
  /// 图片预览文本
  #[serde(rename = "summary", default, skip_serializing_if = "Option::is_none")]
  pub summary: Option<String>,
}

/// 语音消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingSegmentRecordData {
  /// 文件 URI，支持 `file://` `http(s)://` `base64://` 三种格式
  #[serde(rename = "uri")]
  pub uri: String,
}

/// 视频消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingSegmentVideoData {
  /// 文件 URI，支持 `file://` `http(s)://` `base64://` 三种格式
  #[serde(rename = "uri")]
  pub uri: String,
  /// 封面图片 URI
  #[serde(rename = "thumb_uri", default, skip_serializing_if = "Option::is_none")]
  pub thumb_uri: Option<String>,
}

/// 合并转发消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingSegmentForwardData {
  /// 合并转发消息内容
  #[serde(rename = "messages")]
  pub messages: Vec<OutgoingForwardedMessage>,
  /// 合并转发标题
  #[serde(rename = "title", default, skip_serializing_if = "Option::is_none")]
  pub title: Option<String>,
  /// 合并转发预览文本，若提供，至少 1 条，至多 4 条
  #[serde(rename = "preview", default, skip_serializing_if = "Option::is_none")]
  pub preview: Option<Vec<String>>,
  /// 合并转发摘要
  #[serde(rename = "summary", default, skip_serializing_if = "Option::is_none")]
  pub summary: Option<String>,
  /// 合并转发的预览外显文本，仅对移动端 QQ 有效
  #[serde(rename = "prompt", default, skip_serializing_if = "Option::is_none")]
  pub prompt: Option<String>,
}

/// 小程序消息段数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutgoingSegmentLightAppData {
  /// 小程序 JSON 数据
  #[serde(rename = "json_payload")]
  pub json_payload: String,
}

// ####################################
// API Input and Output Structs
// ####################################

// ---- 系统 API ----

/// 获取登录信息 API 请求参数
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct GetLoginInfoInput {}

/// 获取登录信息 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetLoginInfoOutput {
  /// 登录 QQ 号
  #[serde(rename = "uin")]
  pub uin: i64,
  /// 登录昵称
  #[serde(rename = "nickname")]
  pub nickname: String,
}

/// 获取协议端信息 API 请求参数
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct GetImplInfoInput {}

/// 获取协议端信息 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetImplInfoOutput {
  /// 协议端名称
  #[serde(rename = "impl_name")]
  pub impl_name: String,
  /// 协议端版本
  #[serde(rename = "impl_version")]
  pub impl_version: String,
  /// 协议端使用的 QQ 协议版本
  #[serde(rename = "qq_protocol_version")]
  pub qq_protocol_version: String,
  /// 协议端使用的 QQ 协议平台
  #[serde(rename = "qq_protocol_type")]
  pub qq_protocol_type: String,
  /// 协议端实现的 Milky 协议版本，目前为 "1.2"
  #[serde(rename = "milky_version")]
  pub milky_version: String,
}

/// 获取用户个人信息 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetUserProfileInput {
  /// 用户 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
}

/// 获取用户个人信息 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetUserProfileOutput {
  /// 昵称
  #[serde(rename = "nickname")]
  pub nickname: String,
  /// QID
  #[serde(rename = "qid")]
  pub qid: String,
  /// 年龄
  #[serde(rename = "age")]
  pub age: i32,
  /// 性别
  #[serde(rename = "sex")]
  pub sex: String,
  /// 备注
  #[serde(rename = "remark")]
  pub remark: String,
  /// 个性签名
  #[serde(rename = "bio")]
  pub bio: String,
  /// QQ 等级
  #[serde(rename = "level")]
  pub level: i32,
  /// 国家或地区
  #[serde(rename = "country")]
  pub country: String,
  /// 城市
  #[serde(rename = "city")]
  pub city: String,
  /// 学校
  #[serde(rename = "school")]
  pub school: String,
}

/// 获取好友列表 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetFriendListInput {
  /// 是否强制不使用缓存
  #[serde(
    rename = "no_cache",
    default = "default_get_friend_list_input_no_cache",
    deserialize_with = "deserialize_get_friend_list_input_no_cache"
  )]
  pub no_cache: bool,
}

/// 获取好友列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetFriendListOutput {
  /// 好友列表
  #[serde(rename = "friends")]
  pub friends: Vec<FriendEntity>,
}

/// 获取好友信息 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetFriendInfoInput {
  /// 好友 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 是否强制不使用缓存
  #[serde(
    rename = "no_cache",
    default = "default_get_friend_info_input_no_cache",
    deserialize_with = "deserialize_get_friend_info_input_no_cache"
  )]
  pub no_cache: bool,
}

/// 获取好友信息 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetFriendInfoOutput {
  /// 好友信息
  #[serde(rename = "friend")]
  pub friend: FriendEntity,
}

/// 获取群列表 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupListInput {
  /// 是否强制不使用缓存
  #[serde(
    rename = "no_cache",
    default = "default_get_group_list_input_no_cache",
    deserialize_with = "deserialize_get_group_list_input_no_cache"
  )]
  pub no_cache: bool,
}

/// 获取群列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupListOutput {
  /// 群列表
  #[serde(rename = "groups")]
  pub groups: Vec<GroupEntity>,
}

/// 获取群信息 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupInfoInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 是否强制不使用缓存
  #[serde(
    rename = "no_cache",
    default = "default_get_group_info_input_no_cache",
    deserialize_with = "deserialize_get_group_info_input_no_cache"
  )]
  pub no_cache: bool,
}

/// 获取群信息 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupInfoOutput {
  /// 群信息
  #[serde(rename = "group")]
  pub group: GroupEntity,
}

/// 获取群成员列表 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupMemberListInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 是否强制不使用缓存
  #[serde(
    rename = "no_cache",
    default = "default_get_group_member_list_input_no_cache",
    deserialize_with = "deserialize_get_group_member_list_input_no_cache"
  )]
  pub no_cache: bool,
}

/// 获取群成员列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupMemberListOutput {
  /// 群成员列表
  #[serde(rename = "members")]
  pub members: Vec<GroupMemberEntity>,
}

/// 获取群成员信息 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupMemberInfoInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 群成员 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 是否强制不使用缓存
  #[serde(
    rename = "no_cache",
    default = "default_get_group_member_info_input_no_cache",
    deserialize_with = "deserialize_get_group_member_info_input_no_cache"
  )]
  pub no_cache: bool,
}

/// 获取群成员信息 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupMemberInfoOutput {
  /// 群成员信息
  #[serde(rename = "member")]
  pub member: GroupMemberEntity,
}

/// 获取置顶的好友和群列表 API 请求参数
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct GetPeerPinsInput {}

/// 获取置顶的好友和群列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetPeerPinsOutput {
  /// 置顶的好友列表
  #[serde(rename = "friends")]
  pub friends: Vec<FriendEntity>,
  /// 置顶的群列表
  #[serde(rename = "groups")]
  pub groups: Vec<GroupEntity>,
}

/// 设置好友或群的置顶状态 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetPeerPinInput {
  /// 要设置的会话的消息场景
  #[serde(rename = "message_scene")]
  pub message_scene: String,
  /// 要设置的好友 QQ 号或群号
  #[serde(rename = "peer_id")]
  pub peer_id: i64,
  /// 是否置顶, `false` 表示取消置顶
  #[serde(
    rename = "is_pinned",
    default = "default_set_peer_pin_input_is_pinned",
    deserialize_with = "deserialize_set_peer_pin_input_is_pinned"
  )]
  pub is_pinned: bool,
}

/// 设置好友或群的置顶状态 API 响应数据
pub type SetPeerPinOutput = ApiEmptyStruct;

/// 设置 QQ 账号头像 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetAvatarInput {
  /// 头像文件 URI，支持 `file://` `http(s)://` `base64://` 三种格式
  #[serde(rename = "uri")]
  pub uri: String,
}

/// 设置 QQ 账号头像 API 响应数据
pub type SetAvatarOutput = ApiEmptyStruct;

/// 设置 QQ 账号昵称 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetNicknameInput {
  /// 新昵称
  #[serde(rename = "new_nickname")]
  pub new_nickname: String,
}

/// 设置 QQ 账号昵称 API 响应数据
pub type SetNicknameOutput = ApiEmptyStruct;

/// 设置 QQ 账号个性签名 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetBioInput {
  /// 新个性签名
  #[serde(rename = "new_bio")]
  pub new_bio: String,
}

/// 设置 QQ 账号个性签名 API 响应数据
pub type SetBioOutput = ApiEmptyStruct;

/// 获取自定义表情 URL 列表 API 请求参数
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct GetCustomFaceUrlListInput {}

/// 获取自定义表情 URL 列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetCustomFaceUrlListOutput {
  /// 自定义表情 URL 列表
  #[serde(rename = "urls")]
  pub urls: Vec<String>,
}

/// 获取 Cookies API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetCookiesInput {
  /// 需要获取 Cookies 的域名
  #[serde(rename = "domain")]
  pub domain: String,
}

/// 获取 Cookies API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetCookiesOutput {
  /// 域名对应的 Cookies 字符串
  #[serde(rename = "cookies")]
  pub cookies: String,
}

/// 获取 CSRF Token API 请求参数
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct GetCsrfTokenInput {}

/// 获取 CSRF Token API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetCsrfTokenOutput {
  /// CSRF Token
  #[serde(rename = "csrf_token")]
  pub csrf_token: String,
}

// ---- 消息 API ----

/// 发送私聊消息 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SendPrivateMessageInput {
  /// 好友 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 消息内容
  #[serde(
    rename = "message",
    deserialize_with = "deserialize_drop_bad_outgoing_segment_list"
  )]
  pub message: Vec<OutgoingSegment>,
}

/// 发送私聊消息 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SendPrivateMessageOutput {
  /// 消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
  /// 消息发送时间
  #[serde(rename = "time")]
  pub time: i64,
}

/// 发送群聊消息 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SendGroupMessageInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 消息内容
  #[serde(
    rename = "message",
    deserialize_with = "deserialize_drop_bad_outgoing_segment_list"
  )]
  pub message: Vec<OutgoingSegment>,
}

/// 发送群聊消息 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SendGroupMessageOutput {
  /// 消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
  /// 消息发送时间
  #[serde(rename = "time")]
  pub time: i64,
}

/// 撤回私聊消息 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RecallPrivateMessageInput {
  /// 好友 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
}

/// 撤回私聊消息 API 响应数据
pub type RecallPrivateMessageOutput = ApiEmptyStruct;

/// 撤回群聊消息 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RecallGroupMessageInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
}

/// 撤回群聊消息 API 响应数据
pub type RecallGroupMessageOutput = ApiEmptyStruct;

/// 获取消息 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetMessageInput {
  /// 消息场景
  #[serde(rename = "message_scene")]
  pub message_scene: String,
  /// 好友 QQ 号或群号
  #[serde(rename = "peer_id")]
  pub peer_id: i64,
  /// 消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
}

/// 获取消息 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetMessageOutput {
  /// 消息内容
  #[serde(rename = "message")]
  pub message: IncomingMessage,
}

/// 获取历史消息列表 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetHistoryMessagesInput {
  /// 消息场景
  #[serde(rename = "message_scene")]
  pub message_scene: String,
  /// 好友 QQ 号或群号
  #[serde(rename = "peer_id")]
  pub peer_id: i64,
  /// 起始消息序列号，由此开始从新到旧查询，不提供则从最新消息开始
  #[serde(
    rename = "start_message_seq",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub start_message_seq: Option<i64>,
  /// 期望获取到的消息数量，最多 30 条
  #[serde(
    rename = "limit",
    default = "default_get_history_messages_input_limit",
    deserialize_with = "deserialize_get_history_messages_input_limit"
  )]
  pub limit: i32,
}

/// 获取历史消息列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetHistoryMessagesOutput {
  /// 获取到的消息（message_seq 升序排列），部分消息可能不存在，如撤回的消息
  #[serde(
    rename = "messages",
    deserialize_with = "deserialize_drop_bad_incoming_message_list"
  )]
  pub messages: Vec<IncomingMessage>,
  /// 下一页起始消息序列号
  #[serde(
    rename = "next_message_seq",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub next_message_seq: Option<i64>,
}

/// 获取临时资源链接 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetResourceTempUrlInput {
  /// 资源 ID
  #[serde(rename = "resource_id")]
  pub resource_id: String,
}

/// 获取临时资源链接 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetResourceTempUrlOutput {
  /// 临时资源链接
  #[serde(rename = "url")]
  pub url: String,
}

/// 获取合并转发消息内容 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetForwardedMessagesInput {
  /// 转发消息 ID
  #[serde(rename = "forward_id")]
  pub forward_id: String,
}

/// 获取合并转发消息内容 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetForwardedMessagesOutput {
  /// 转发消息内容
  #[serde(rename = "messages")]
  pub messages: Vec<IncomingForwardedMessage>,
}

/// 标记消息为已读 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MarkMessageAsReadInput {
  /// 消息场景
  #[serde(rename = "message_scene")]
  pub message_scene: String,
  /// 好友 QQ 号或群号
  #[serde(rename = "peer_id")]
  pub peer_id: i64,
  /// 标为已读的消息序列号，该消息及更早的消息将被标记为已读
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
}

/// 标记消息为已读 API 响应数据
pub type MarkMessageAsReadOutput = ApiEmptyStruct;

// ---- 好友 API ----

/// 发送好友戳一戳 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SendFriendNudgeInput {
  /// 好友 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 是否戳自己
  #[serde(
    rename = "is_self",
    default = "default_send_friend_nudge_input_is_self",
    deserialize_with = "deserialize_send_friend_nudge_input_is_self"
  )]
  pub is_self: bool,
}

/// 发送好友戳一戳 API 响应数据
pub type SendFriendNudgeOutput = ApiEmptyStruct;

/// 发送名片点赞 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SendProfileLikeInput {
  /// 好友 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 点赞数量
  #[serde(
    rename = "count",
    default = "default_send_profile_like_input_count",
    deserialize_with = "deserialize_send_profile_like_input_count"
  )]
  pub count: i32,
}

/// 发送名片点赞 API 响应数据
pub type SendProfileLikeOutput = ApiEmptyStruct;

/// 删除好友 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DeleteFriendInput {
  /// 好友 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
}

/// 删除好友 API 响应数据
pub type DeleteFriendOutput = ApiEmptyStruct;

/// 获取好友请求列表 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetFriendRequestsInput {
  /// 获取的最大请求数量
  #[serde(
    rename = "limit",
    default = "default_get_friend_requests_input_limit",
    deserialize_with = "deserialize_get_friend_requests_input_limit"
  )]
  pub limit: i32,
  /// `true` 表示只获取被过滤（由风险账号发起）的通知，`false` 表示只获取未被过滤的通知
  #[serde(
    rename = "is_filtered",
    default = "default_get_friend_requests_input_is_filtered",
    deserialize_with = "deserialize_get_friend_requests_input_is_filtered"
  )]
  pub is_filtered: bool,
}

/// 获取好友请求列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetFriendRequestsOutput {
  /// 好友请求列表
  #[serde(rename = "requests")]
  pub requests: Vec<FriendRequest>,
}

/// 同意好友请求 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AcceptFriendRequestInput {
  /// 请求发起者 UID
  #[serde(rename = "initiator_uid")]
  pub initiator_uid: String,
  /// 是否是被过滤的请求
  #[serde(
    rename = "is_filtered",
    default = "default_accept_friend_request_input_is_filtered",
    deserialize_with = "deserialize_accept_friend_request_input_is_filtered"
  )]
  pub is_filtered: bool,
}

/// 同意好友请求 API 响应数据
pub type AcceptFriendRequestOutput = ApiEmptyStruct;

/// 拒绝好友请求 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RejectFriendRequestInput {
  /// 请求发起者 UID
  #[serde(rename = "initiator_uid")]
  pub initiator_uid: String,
  /// 是否是被过滤的请求
  #[serde(
    rename = "is_filtered",
    default = "default_reject_friend_request_input_is_filtered",
    deserialize_with = "deserialize_reject_friend_request_input_is_filtered"
  )]
  pub is_filtered: bool,
  /// 拒绝理由
  #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
  pub reason: Option<String>,
}

/// 拒绝好友请求 API 响应数据
pub type RejectFriendRequestOutput = ApiEmptyStruct;

// ---- 群聊 API ----

/// 设置群名称 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetGroupNameInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 新群名称
  #[serde(rename = "new_group_name")]
  pub new_group_name: String,
}

/// 设置群名称 API 响应数据
pub type SetGroupNameOutput = ApiEmptyStruct;

/// 设置群头像 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetGroupAvatarInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 头像文件 URI，支持 `file://` `http(s)://` `base64://` 三种格式
  #[serde(rename = "image_uri")]
  pub image_uri: String,
}

/// 设置群头像 API 响应数据
pub type SetGroupAvatarOutput = ApiEmptyStruct;

/// 设置群名片 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetGroupMemberCardInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 被设置的群成员 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 新群名片
  #[serde(rename = "card")]
  pub card: String,
}

/// 设置群名片 API 响应数据
pub type SetGroupMemberCardOutput = ApiEmptyStruct;

/// 设置群成员专属头衔 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetGroupMemberSpecialTitleInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 被设置的群成员 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 新专属头衔
  #[serde(rename = "special_title")]
  pub special_title: String,
}

/// 设置群成员专属头衔 API 响应数据
pub type SetGroupMemberSpecialTitleOutput = ApiEmptyStruct;

/// 设置群管理员 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetGroupMemberAdminInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 被设置的 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 是否设置为管理员，`false` 表示取消管理员
  #[serde(
    rename = "is_set",
    default = "default_set_group_member_admin_input_is_set",
    deserialize_with = "deserialize_set_group_member_admin_input_is_set"
  )]
  pub is_set: bool,
}

/// 设置群管理员 API 响应数据
pub type SetGroupMemberAdminOutput = ApiEmptyStruct;

/// 设置群成员禁言 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetGroupMemberMuteInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 被设置的 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 禁言持续时间（秒），设为 `0` 为取消禁言
  #[serde(
    rename = "duration",
    default = "default_set_group_member_mute_input_duration",
    deserialize_with = "deserialize_set_group_member_mute_input_duration"
  )]
  pub duration: i32,
}

/// 设置群成员禁言 API 响应数据
pub type SetGroupMemberMuteOutput = ApiEmptyStruct;

/// 设置群全员禁言 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetGroupWholeMuteInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 是否开启全员禁言，`false` 表示取消全员禁言
  #[serde(
    rename = "is_mute",
    default = "default_set_group_whole_mute_input_is_mute",
    deserialize_with = "deserialize_set_group_whole_mute_input_is_mute"
  )]
  pub is_mute: bool,
}

/// 设置群全员禁言 API 响应数据
pub type SetGroupWholeMuteOutput = ApiEmptyStruct;

/// 踢出群成员 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct KickGroupMemberInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 被踢的 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 是否拒绝加群申请，`false` 表示不拒绝
  #[serde(
    rename = "reject_add_request",
    default = "default_kick_group_member_input_reject_add_request",
    deserialize_with = "deserialize_kick_group_member_input_reject_add_request"
  )]
  pub reject_add_request: bool,
}

/// 踢出群成员 API 响应数据
pub type KickGroupMemberOutput = ApiEmptyStruct;

/// 获取群公告列表 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupAnnouncementsInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
}

/// 获取群公告列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupAnnouncementsOutput {
  /// 群公告列表
  #[serde(rename = "announcements")]
  pub announcements: Vec<GroupAnnouncementEntity>,
}

/// 发送群公告 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SendGroupAnnouncementInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 公告内容
  #[serde(rename = "content")]
  pub content: String,
  /// 公告附带图像文件 URI，支持 `file://` `http(s)://` `base64://` 三种格式
  #[serde(rename = "image_uri", default, skip_serializing_if = "Option::is_none")]
  pub image_uri: Option<String>,
}

/// 发送群公告 API 响应数据
pub type SendGroupAnnouncementOutput = ApiEmptyStruct;

/// 删除群公告 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DeleteGroupAnnouncementInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 公告 ID
  #[serde(rename = "announcement_id")]
  pub announcement_id: String,
}

/// 删除群公告 API 响应数据
pub type DeleteGroupAnnouncementOutput = ApiEmptyStruct;

/// 获取群精华消息列表 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupEssenceMessagesInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 页码索引，从 0 开始
  #[serde(rename = "page_index")]
  pub page_index: i32,
  /// 每页包含的精华消息数量
  #[serde(rename = "page_size")]
  pub page_size: i32,
}

/// 获取群精华消息列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupEssenceMessagesOutput {
  /// 精华消息列表
  #[serde(rename = "messages")]
  pub messages: Vec<GroupEssenceMessage>,
  /// 是否已到最后一页
  #[serde(rename = "is_end")]
  pub is_end: bool,
}

/// 设置群精华消息 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetGroupEssenceMessageInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
  /// 是否设置为精华消息，`false` 表示取消精华
  #[serde(
    rename = "is_set",
    default = "default_set_group_essence_message_input_is_set",
    deserialize_with = "deserialize_set_group_essence_message_input_is_set"
  )]
  pub is_set: bool,
}

/// 设置群精华消息 API 响应数据
pub type SetGroupEssenceMessageOutput = ApiEmptyStruct;

/// 退出群 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuitGroupInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
}

/// 退出群 API 响应数据
pub type QuitGroupOutput = ApiEmptyStruct;

/// 发送群消息表情回应 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SendGroupMessageReactionInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 要回应的消息序列号
  #[serde(rename = "message_seq")]
  pub message_seq: i64,
  /// 发送的回应的表情 ID
  #[serde(rename = "reaction")]
  pub reaction: String,
  /// 发送的回应类型
  #[serde(
    rename = "reaction_type",
    default = "default_send_group_message_reaction_input_reaction_type",
    deserialize_with = "deserialize_send_group_message_reaction_input_reaction_type"
  )]
  pub reaction_type: String,
  /// 是否添加表情，`false` 表示取消
  #[serde(
    rename = "is_add",
    default = "default_send_group_message_reaction_input_is_add",
    deserialize_with = "deserialize_send_group_message_reaction_input_is_add"
  )]
  pub is_add: bool,
}

/// 发送群消息表情回应 API 响应数据
pub type SendGroupMessageReactionOutput = ApiEmptyStruct;

/// 发送群戳一戳 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SendGroupNudgeInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 被戳的群成员 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
}

/// 发送群戳一戳 API 响应数据
pub type SendGroupNudgeOutput = ApiEmptyStruct;

/// 获取群通知列表 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupNotificationsInput {
  /// 起始通知序列号
  #[serde(
    rename = "start_notification_seq",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub start_notification_seq: Option<i64>,
  /// `true` 表示只获取被过滤（由风险账号发起）的通知，`false` 表示只获取未被过滤的通知
  #[serde(
    rename = "is_filtered",
    default = "default_get_group_notifications_input_is_filtered",
    deserialize_with = "deserialize_get_group_notifications_input_is_filtered"
  )]
  pub is_filtered: bool,
  /// 获取的最大通知数量
  #[serde(
    rename = "limit",
    default = "default_get_group_notifications_input_limit",
    deserialize_with = "deserialize_get_group_notifications_input_limit"
  )]
  pub limit: i32,
}

/// 获取群通知列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupNotificationsOutput {
  /// 获取到的群通知（notification_seq 降序排列），序列号不一定连续
  #[serde(
    rename = "notifications",
    deserialize_with = "deserialize_drop_bad_group_notification_list"
  )]
  pub notifications: Vec<GroupNotification>,
  /// 下一页起始通知序列号
  #[serde(
    rename = "next_notification_seq",
    default,
    skip_serializing_if = "Option::is_none"
  )]
  pub next_notification_seq: Option<i64>,
}

/// 同意入群/邀请他人入群请求 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AcceptGroupRequestInput {
  /// 请求对应的通知序列号
  #[serde(rename = "notification_seq")]
  pub notification_seq: i64,
  /// 请求对应的通知类型
  #[serde(rename = "notification_type")]
  pub notification_type: String,
  /// 请求所在的群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 是否是被过滤的请求
  #[serde(
    rename = "is_filtered",
    default = "default_accept_group_request_input_is_filtered",
    deserialize_with = "deserialize_accept_group_request_input_is_filtered"
  )]
  pub is_filtered: bool,
}

/// 同意入群/邀请他人入群请求 API 响应数据
pub type AcceptGroupRequestOutput = ApiEmptyStruct;

/// 拒绝入群/邀请他人入群请求 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RejectGroupRequestInput {
  /// 请求对应的通知序列号
  #[serde(rename = "notification_seq")]
  pub notification_seq: i64,
  /// 请求对应的通知类型
  #[serde(rename = "notification_type")]
  pub notification_type: String,
  /// 请求所在的群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 是否是被过滤的请求
  #[serde(
    rename = "is_filtered",
    default = "default_reject_group_request_input_is_filtered",
    deserialize_with = "deserialize_reject_group_request_input_is_filtered"
  )]
  pub is_filtered: bool,
  /// 拒绝理由
  #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
  pub reason: Option<String>,
}

/// 拒绝入群/邀请他人入群请求 API 响应数据
pub type RejectGroupRequestOutput = ApiEmptyStruct;

/// 同意他人邀请自身入群 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AcceptGroupInvitationInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 邀请序列号
  #[serde(rename = "invitation_seq")]
  pub invitation_seq: i64,
}

/// 同意他人邀请自身入群 API 响应数据
pub type AcceptGroupInvitationOutput = ApiEmptyStruct;

/// 拒绝他人邀请自身入群 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RejectGroupInvitationInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 邀请序列号
  #[serde(rename = "invitation_seq")]
  pub invitation_seq: i64,
}

/// 拒绝他人邀请自身入群 API 响应数据
pub type RejectGroupInvitationOutput = ApiEmptyStruct;

// ---- 文件 API ----

/// 上传私聊文件 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UploadPrivateFileInput {
  /// 好友 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 文件 URI，支持 `file://` `http(s)://` `base64://` 三种格式
  #[serde(rename = "file_uri")]
  pub file_uri: String,
  /// 文件名称
  #[serde(rename = "file_name")]
  pub file_name: String,
}

/// 上传私聊文件 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UploadPrivateFileOutput {
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
}

/// 上传群文件 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UploadGroupFileInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 目标文件夹 ID
  #[serde(
    rename = "parent_folder_id",
    default = "default_upload_group_file_input_parent_folder_id",
    deserialize_with = "deserialize_upload_group_file_input_parent_folder_id"
  )]
  pub parent_folder_id: String,
  /// 文件 URI，支持 `file://` `http(s)://` `base64://` 三种格式
  #[serde(rename = "file_uri")]
  pub file_uri: String,
  /// 文件名称
  #[serde(rename = "file_name")]
  pub file_name: String,
}

/// 上传群文件 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UploadGroupFileOutput {
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
}

/// 获取私聊文件下载链接 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetPrivateFileDownloadUrlInput {
  /// 好友 QQ 号
  #[serde(rename = "user_id")]
  pub user_id: i64,
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
  /// 文件的 TriSHA1 哈希值
  #[serde(rename = "file_hash")]
  pub file_hash: String,
}

/// 获取私聊文件下载链接 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetPrivateFileDownloadUrlOutput {
  /// 文件下载链接
  #[serde(rename = "download_url")]
  pub download_url: String,
}

/// 获取群文件下载链接 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupFileDownloadUrlInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
}

/// 获取群文件下载链接 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupFileDownloadUrlOutput {
  /// 文件下载链接
  #[serde(rename = "download_url")]
  pub download_url: String,
}

/// 获取群文件列表 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupFilesInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 父文件夹 ID
  #[serde(
    rename = "parent_folder_id",
    default = "default_get_group_files_input_parent_folder_id",
    deserialize_with = "deserialize_get_group_files_input_parent_folder_id"
  )]
  pub parent_folder_id: String,
}

/// 获取群文件列表 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GetGroupFilesOutput {
  /// 文件列表
  #[serde(rename = "files")]
  pub files: Vec<GroupFileEntity>,
  /// 文件夹列表
  #[serde(rename = "folders")]
  pub folders: Vec<GroupFolderEntity>,
}

/// 移动群文件 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MoveGroupFileInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
  /// 文件所在的文件夹 ID
  #[serde(
    rename = "parent_folder_id",
    default = "default_move_group_file_input_parent_folder_id",
    deserialize_with = "deserialize_move_group_file_input_parent_folder_id"
  )]
  pub parent_folder_id: String,
  /// 目标文件夹 ID
  #[serde(
    rename = "target_folder_id",
    default = "default_move_group_file_input_target_folder_id",
    deserialize_with = "deserialize_move_group_file_input_target_folder_id"
  )]
  pub target_folder_id: String,
}

/// 移动群文件 API 响应数据
pub type MoveGroupFileOutput = ApiEmptyStruct;

/// 重命名群文件 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RenameGroupFileInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
  /// 文件所在的文件夹 ID
  #[serde(
    rename = "parent_folder_id",
    default = "default_rename_group_file_input_parent_folder_id",
    deserialize_with = "deserialize_rename_group_file_input_parent_folder_id"
  )]
  pub parent_folder_id: String,
  /// 新文件名称
  #[serde(rename = "new_file_name")]
  pub new_file_name: String,
}

/// 重命名群文件 API 响应数据
pub type RenameGroupFileOutput = ApiEmptyStruct;

/// 删除群文件 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DeleteGroupFileInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 文件 ID
  #[serde(rename = "file_id")]
  pub file_id: String,
}

/// 删除群文件 API 响应数据
pub type DeleteGroupFileOutput = ApiEmptyStruct;

/// 创建群文件夹 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateGroupFolderInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 文件夹名称
  #[serde(rename = "folder_name")]
  pub folder_name: String,
}

/// 创建群文件夹 API 响应数据
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateGroupFolderOutput {
  /// 文件夹 ID
  #[serde(rename = "folder_id")]
  pub folder_id: String,
}

/// 重命名群文件夹 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RenameGroupFolderInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 文件夹 ID
  #[serde(rename = "folder_id")]
  pub folder_id: String,
  /// 新文件夹名
  #[serde(rename = "new_folder_name")]
  pub new_folder_name: String,
}

/// 重命名群文件夹 API 响应数据
pub type RenameGroupFolderOutput = ApiEmptyStruct;

/// 删除群文件夹 API 请求参数
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DeleteGroupFolderInput {
  /// 群号
  #[serde(rename = "group_id")]
  pub group_id: i64,
  /// 文件夹 ID
  #[serde(rename = "folder_id")]
  pub folder_id: String,
}

/// 删除群文件夹 API 响应数据
pub type DeleteGroupFolderOutput = ApiEmptyStruct;

// ####################################
// Serde Helpers
// ####################################

fn serialize_segment_with_data<S, T>(
  serializer: S,
  segment_type: &str,
  data: &T,
) -> Result<S::Ok, S::Error>
where
  S: Serializer,
  T: Serialize,
{
  serde_json::json!({
      "type": segment_type,
      "data": data,
  })
  .serialize(serializer)
}

fn serialize_segment_with_field<S, T>(
  serializer: S,
  segment_type: &str,
  field_name: &str,
  value: &T,
) -> Result<S::Ok, S::Error>
where
  S: Serializer,
  T: Serialize,
{
  let mut object = serde_json::Map::with_capacity(2);
  object.insert(
    "type".to_string(),
    serde_json::Value::String(segment_type.to_string()),
  );
  object.insert(
    field_name.to_string(),
    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
  );
  serde_json::Value::Object(object).serialize(serializer)
}

fn deserialize_segment_type<E>(value: &serde_json::Value) -> Result<&str, E>
where
  E: serde::de::Error,
{
  value
    .get("type")
    .and_then(serde_json::Value::as_str)
    .ok_or_else(|| E::missing_field("type"))
}

fn deserialize_segment_data<E, T>(value: &serde_json::Value) -> Result<T, E>
where
  E: serde::de::Error,
  T: DeserializeOwned,
{
  let data = value
    .get("data")
    .cloned()
    .ok_or_else(|| E::missing_field("data"))?;
  serde_json::from_value(data).map_err(E::custom)
}

fn deserialize_segment_field<E, T>(
  value: &serde_json::Value,
  field_name: &'static str,
) -> Result<T, E>
where
  E: serde::de::Error,
  T: DeserializeOwned,
{
  let field_value = value
    .get(field_name)
    .cloned()
    .ok_or_else(|| E::missing_field(field_name))?;
  serde_json::from_value(field_value).map_err(E::custom)
}

fn deserialize_drop_bad_element_list<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
where
  D: Deserializer<'de>,
  T: serde::de::DeserializeOwned,
{
  let values = Option::<Vec<serde_json::Value>>::deserialize(deserializer)?.unwrap_or_default();
  let mut out = Vec::with_capacity(values.len());
  for value in values {
    if let Ok(item) = serde_json::from_value::<T>(value) {
      out.push(item);
    }
  }
  Ok(out)
}

fn deserialize_optional_drop_bad_element_list<'de, D, T>(
  deserializer: D,
) -> Result<Option<Vec<T>>, D::Error>
where
  D: Deserializer<'de>,
  T: serde::de::DeserializeOwned,
{
  let values = Option::<Vec<serde_json::Value>>::deserialize(deserializer)?;
  let Some(values) = values else {
    return Ok(None);
  };
  let mut out = Vec::with_capacity(values.len());
  for value in values {
    if let Ok(item) = serde_json::from_value::<T>(value) {
      out.push(item);
    }
  }
  Ok(Some(out))
}

fn unknown_incoming_segment(value: serde_json::Value) -> IncomingSegment {
  let type_value = value
    .as_object()
    .and_then(|object| object.get("type"))
    .and_then(serde_json::Value::as_str)
    .unwrap_or("unknown");
  IncomingSegment::Text(format!("[{}]", type_value))
}

fn deserialize_incoming_segment_list<'de, D>(
  deserializer: D,
) -> Result<Vec<IncomingSegment>, D::Error>
where
  D: Deserializer<'de>,
{
  let values = Option::<Vec<serde_json::Value>>::deserialize(deserializer)?.unwrap_or_default();
  let mut out = Vec::with_capacity(values.len());
  for value in values {
    match serde_json::from_value::<IncomingSegment>(value.clone()) {
      Ok(item) => out.push(item),
      Err(_) => out.push(unknown_incoming_segment(value)),
    }
  }
  Ok(out)
}

fn deserialize_optional_incoming_segment_list<'de, D>(
  deserializer: D,
) -> Result<Option<Vec<IncomingSegment>>, D::Error>
where
  D: Deserializer<'de>,
{
  let values = Option::<Vec<serde_json::Value>>::deserialize(deserializer)?;
  let Some(values) = values else {
    return Ok(None);
  };
  let mut out = Vec::with_capacity(values.len());
  for value in values {
    match serde_json::from_value::<IncomingSegment>(value.clone()) {
      Ok(item) => out.push(item),
      Err(_) => out.push(unknown_incoming_segment(value)),
    }
  }
  Ok(Some(out))
}

fn deserialize_drop_bad_outgoing_segment_list<'de, D>(
  deserializer: D,
) -> Result<Vec<OutgoingSegment>, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_drop_bad_element_list::<D, OutgoingSegment>(deserializer)
}

fn deserialize_optional_drop_bad_outgoing_segment_list<'de, D>(
  deserializer: D,
) -> Result<Option<Vec<OutgoingSegment>>, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_optional_drop_bad_element_list::<D, OutgoingSegment>(deserializer)
}

fn deserialize_drop_bad_incoming_message_list<'de, D>(
  deserializer: D,
) -> Result<Vec<IncomingMessage>, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_drop_bad_element_list::<D, IncomingMessage>(deserializer)
}

fn deserialize_optional_drop_bad_incoming_message_list<'de, D>(
  deserializer: D,
) -> Result<Option<Vec<IncomingMessage>>, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_optional_drop_bad_element_list::<D, IncomingMessage>(deserializer)
}

fn deserialize_drop_bad_group_notification_list<'de, D>(
  deserializer: D,
) -> Result<Vec<GroupNotification>, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_drop_bad_element_list::<D, GroupNotification>(deserializer)
}

fn deserialize_optional_drop_bad_group_notification_list<'de, D>(
  deserializer: D,
) -> Result<Option<Vec<GroupNotification>>, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_optional_drop_bad_element_list::<D, GroupNotification>(deserializer)
}

fn deserialize_default_on_null<'de, D, T, F>(deserializer: D, default: F) -> Result<T, D::Error>
where
  D: Deserializer<'de>,
  T: Deserialize<'de>,
  F: FnOnce() -> T,
{
  Ok(Option::<T>::deserialize(deserializer)?.unwrap_or_else(default))
}

fn default_outgoing_segment_face_data_is_large() -> bool {
  false
}

fn deserialize_outgoing_segment_face_data_is_large<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_outgoing_segment_face_data_is_large)
}
fn default_outgoing_segment_image_data_sub_type() -> String {
  "normal".to_string()
}

fn deserialize_outgoing_segment_image_data_sub_type<'de, D>(
  deserializer: D,
) -> Result<String, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_outgoing_segment_image_data_sub_type)
}
fn default_get_friend_list_input_no_cache() -> bool {
  false
}

fn deserialize_get_friend_list_input_no_cache<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_friend_list_input_no_cache)
}
fn default_get_friend_info_input_no_cache() -> bool {
  false
}

fn deserialize_get_friend_info_input_no_cache<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_friend_info_input_no_cache)
}
fn default_get_group_list_input_no_cache() -> bool {
  false
}

fn deserialize_get_group_list_input_no_cache<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_group_list_input_no_cache)
}
fn default_get_group_info_input_no_cache() -> bool {
  false
}

fn deserialize_get_group_info_input_no_cache<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_group_info_input_no_cache)
}
fn default_get_group_member_list_input_no_cache() -> bool {
  false
}

fn deserialize_get_group_member_list_input_no_cache<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_group_member_list_input_no_cache)
}
fn default_get_group_member_info_input_no_cache() -> bool {
  false
}

fn deserialize_get_group_member_info_input_no_cache<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_group_member_info_input_no_cache)
}
fn default_set_peer_pin_input_is_pinned() -> bool {
  true
}

fn deserialize_set_peer_pin_input_is_pinned<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_set_peer_pin_input_is_pinned)
}
fn default_get_history_messages_input_limit() -> i32 {
  20
}

fn deserialize_get_history_messages_input_limit<'de, D>(deserializer: D) -> Result<i32, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_history_messages_input_limit)
}
fn default_send_friend_nudge_input_is_self() -> bool {
  false
}

fn deserialize_send_friend_nudge_input_is_self<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_send_friend_nudge_input_is_self)
}
fn default_send_profile_like_input_count() -> i32 {
  1
}

fn deserialize_send_profile_like_input_count<'de, D>(deserializer: D) -> Result<i32, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_send_profile_like_input_count)
}
fn default_get_friend_requests_input_limit() -> i32 {
  20
}

fn deserialize_get_friend_requests_input_limit<'de, D>(deserializer: D) -> Result<i32, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_friend_requests_input_limit)
}
fn default_get_friend_requests_input_is_filtered() -> bool {
  false
}

fn deserialize_get_friend_requests_input_is_filtered<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_friend_requests_input_is_filtered)
}
fn default_accept_friend_request_input_is_filtered() -> bool {
  false
}

fn deserialize_accept_friend_request_input_is_filtered<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(
    deserializer,
    default_accept_friend_request_input_is_filtered,
  )
}
fn default_reject_friend_request_input_is_filtered() -> bool {
  false
}

fn deserialize_reject_friend_request_input_is_filtered<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(
    deserializer,
    default_reject_friend_request_input_is_filtered,
  )
}
fn default_set_group_member_admin_input_is_set() -> bool {
  true
}

fn deserialize_set_group_member_admin_input_is_set<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_set_group_member_admin_input_is_set)
}
fn default_set_group_member_mute_input_duration() -> i32 {
  0
}

fn deserialize_set_group_member_mute_input_duration<'de, D>(
  deserializer: D,
) -> Result<i32, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_set_group_member_mute_input_duration)
}
fn default_set_group_whole_mute_input_is_mute() -> bool {
  true
}

fn deserialize_set_group_whole_mute_input_is_mute<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_set_group_whole_mute_input_is_mute)
}
fn default_kick_group_member_input_reject_add_request() -> bool {
  false
}

fn deserialize_kick_group_member_input_reject_add_request<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(
    deserializer,
    default_kick_group_member_input_reject_add_request,
  )
}
fn default_set_group_essence_message_input_is_set() -> bool {
  true
}

fn deserialize_set_group_essence_message_input_is_set<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_set_group_essence_message_input_is_set)
}
fn default_send_group_message_reaction_input_reaction_type() -> String {
  "face".to_string()
}

fn deserialize_send_group_message_reaction_input_reaction_type<'de, D>(
  deserializer: D,
) -> Result<String, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(
    deserializer,
    default_send_group_message_reaction_input_reaction_type,
  )
}
fn default_send_group_message_reaction_input_is_add() -> bool {
  true
}

fn deserialize_send_group_message_reaction_input_is_add<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(
    deserializer,
    default_send_group_message_reaction_input_is_add,
  )
}
fn default_get_group_notifications_input_is_filtered() -> bool {
  false
}

fn deserialize_get_group_notifications_input_is_filtered<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(
    deserializer,
    default_get_group_notifications_input_is_filtered,
  )
}
fn default_get_group_notifications_input_limit() -> i32 {
  20
}

fn deserialize_get_group_notifications_input_limit<'de, D>(deserializer: D) -> Result<i32, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_group_notifications_input_limit)
}
fn default_accept_group_request_input_is_filtered() -> bool {
  false
}

fn deserialize_accept_group_request_input_is_filtered<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_accept_group_request_input_is_filtered)
}
fn default_reject_group_request_input_is_filtered() -> bool {
  false
}

fn deserialize_reject_group_request_input_is_filtered<'de, D>(
  deserializer: D,
) -> Result<bool, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_reject_group_request_input_is_filtered)
}
fn default_upload_group_file_input_parent_folder_id() -> String {
  "/".to_string()
}

fn deserialize_upload_group_file_input_parent_folder_id<'de, D>(
  deserializer: D,
) -> Result<String, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(
    deserializer,
    default_upload_group_file_input_parent_folder_id,
  )
}
fn default_get_group_files_input_parent_folder_id() -> String {
  "/".to_string()
}

fn deserialize_get_group_files_input_parent_folder_id<'de, D>(
  deserializer: D,
) -> Result<String, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_get_group_files_input_parent_folder_id)
}
fn default_move_group_file_input_parent_folder_id() -> String {
  "/".to_string()
}

fn deserialize_move_group_file_input_parent_folder_id<'de, D>(
  deserializer: D,
) -> Result<String, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_move_group_file_input_parent_folder_id)
}
fn default_move_group_file_input_target_folder_id() -> String {
  "/".to_string()
}

fn deserialize_move_group_file_input_target_folder_id<'de, D>(
  deserializer: D,
) -> Result<String, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(deserializer, default_move_group_file_input_target_folder_id)
}
fn default_rename_group_file_input_parent_folder_id() -> String {
  "/".to_string()
}

fn deserialize_rename_group_file_input_parent_folder_id<'de, D>(
  deserializer: D,
) -> Result<String, D::Error>
where
  D: Deserializer<'de>,
{
  deserialize_default_on_null(
    deserializer,
    default_rename_group_file_input_parent_folder_id,
  )
}

// ####################################
// API Endpoint Constants
// ####################################

pub trait ApiEndpoint: Serialize {
  type Output: DeserializeOwned;
  const NAME: &'static str;
}

/// 获取登录信息
impl ApiEndpoint for GetLoginInfoInput {
  type Output = GetLoginInfoOutput;
  const NAME: &'static str = "get_login_info";
}

/// 获取协议端信息
impl ApiEndpoint for GetImplInfoInput {
  type Output = GetImplInfoOutput;
  const NAME: &'static str = "get_impl_info";
}

/// 获取用户个人信息
impl ApiEndpoint for GetUserProfileInput {
  type Output = GetUserProfileOutput;
  const NAME: &'static str = "get_user_profile";
}

/// 获取好友列表
impl ApiEndpoint for GetFriendListInput {
  type Output = GetFriendListOutput;
  const NAME: &'static str = "get_friend_list";
}

/// 获取好友信息
impl ApiEndpoint for GetFriendInfoInput {
  type Output = GetFriendInfoOutput;
  const NAME: &'static str = "get_friend_info";
}

/// 获取群列表
impl ApiEndpoint for GetGroupListInput {
  type Output = GetGroupListOutput;
  const NAME: &'static str = "get_group_list";
}

/// 获取群信息
impl ApiEndpoint for GetGroupInfoInput {
  type Output = GetGroupInfoOutput;
  const NAME: &'static str = "get_group_info";
}

/// 获取群成员列表
impl ApiEndpoint for GetGroupMemberListInput {
  type Output = GetGroupMemberListOutput;
  const NAME: &'static str = "get_group_member_list";
}

/// 获取群成员信息
impl ApiEndpoint for GetGroupMemberInfoInput {
  type Output = GetGroupMemberInfoOutput;
  const NAME: &'static str = "get_group_member_info";
}

/// 获取置顶的好友和群列表
impl ApiEndpoint for GetPeerPinsInput {
  type Output = GetPeerPinsOutput;
  const NAME: &'static str = "get_peer_pins";
}

/// 设置好友或群的置顶状态
impl ApiEndpoint for SetPeerPinInput {
  type Output = SetPeerPinOutput;
  const NAME: &'static str = "set_peer_pin";
}

/// 设置 QQ 账号头像
impl ApiEndpoint for SetAvatarInput {
  type Output = SetAvatarOutput;
  const NAME: &'static str = "set_avatar";
}

/// 设置 QQ 账号昵称
impl ApiEndpoint for SetNicknameInput {
  type Output = SetNicknameOutput;
  const NAME: &'static str = "set_nickname";
}

/// 设置 QQ 账号个性签名
impl ApiEndpoint for SetBioInput {
  type Output = SetBioOutput;
  const NAME: &'static str = "set_bio";
}

/// 获取自定义表情 URL 列表
impl ApiEndpoint for GetCustomFaceUrlListInput {
  type Output = GetCustomFaceUrlListOutput;
  const NAME: &'static str = "get_custom_face_url_list";
}

/// 获取 Cookies
impl ApiEndpoint for GetCookiesInput {
  type Output = GetCookiesOutput;
  const NAME: &'static str = "get_cookies";
}

/// 获取 CSRF Token
impl ApiEndpoint for GetCsrfTokenInput {
  type Output = GetCsrfTokenOutput;
  const NAME: &'static str = "get_csrf_token";
}

/// 发送私聊消息
impl ApiEndpoint for SendPrivateMessageInput {
  type Output = SendPrivateMessageOutput;
  const NAME: &'static str = "send_private_message";
}

/// 发送群聊消息
impl ApiEndpoint for SendGroupMessageInput {
  type Output = SendGroupMessageOutput;
  const NAME: &'static str = "send_group_message";
}

/// 撤回私聊消息
impl ApiEndpoint for RecallPrivateMessageInput {
  type Output = RecallPrivateMessageOutput;
  const NAME: &'static str = "recall_private_message";
}

/// 撤回群聊消息
impl ApiEndpoint for RecallGroupMessageInput {
  type Output = RecallGroupMessageOutput;
  const NAME: &'static str = "recall_group_message";
}

/// 获取消息
impl ApiEndpoint for GetMessageInput {
  type Output = GetMessageOutput;
  const NAME: &'static str = "get_message";
}

/// 获取历史消息列表
impl ApiEndpoint for GetHistoryMessagesInput {
  type Output = GetHistoryMessagesOutput;
  const NAME: &'static str = "get_history_messages";
}

/// 获取临时资源链接
impl ApiEndpoint for GetResourceTempUrlInput {
  type Output = GetResourceTempUrlOutput;
  const NAME: &'static str = "get_resource_temp_url";
}

/// 获取合并转发消息内容
impl ApiEndpoint for GetForwardedMessagesInput {
  type Output = GetForwardedMessagesOutput;
  const NAME: &'static str = "get_forwarded_messages";
}

/// 标记消息为已读
impl ApiEndpoint for MarkMessageAsReadInput {
  type Output = MarkMessageAsReadOutput;
  const NAME: &'static str = "mark_message_as_read";
}

/// 发送好友戳一戳
impl ApiEndpoint for SendFriendNudgeInput {
  type Output = SendFriendNudgeOutput;
  const NAME: &'static str = "send_friend_nudge";
}

/// 发送名片点赞
impl ApiEndpoint for SendProfileLikeInput {
  type Output = SendProfileLikeOutput;
  const NAME: &'static str = "send_profile_like";
}

/// 删除好友
impl ApiEndpoint for DeleteFriendInput {
  type Output = DeleteFriendOutput;
  const NAME: &'static str = "delete_friend";
}

/// 获取好友请求列表
impl ApiEndpoint for GetFriendRequestsInput {
  type Output = GetFriendRequestsOutput;
  const NAME: &'static str = "get_friend_requests";
}

/// 同意好友请求
impl ApiEndpoint for AcceptFriendRequestInput {
  type Output = AcceptFriendRequestOutput;
  const NAME: &'static str = "accept_friend_request";
}

/// 拒绝好友请求
impl ApiEndpoint for RejectFriendRequestInput {
  type Output = RejectFriendRequestOutput;
  const NAME: &'static str = "reject_friend_request";
}

/// 设置群名称
impl ApiEndpoint for SetGroupNameInput {
  type Output = SetGroupNameOutput;
  const NAME: &'static str = "set_group_name";
}

/// 设置群头像
impl ApiEndpoint for SetGroupAvatarInput {
  type Output = SetGroupAvatarOutput;
  const NAME: &'static str = "set_group_avatar";
}

/// 设置群名片
impl ApiEndpoint for SetGroupMemberCardInput {
  type Output = SetGroupMemberCardOutput;
  const NAME: &'static str = "set_group_member_card";
}

/// 设置群成员专属头衔
impl ApiEndpoint for SetGroupMemberSpecialTitleInput {
  type Output = SetGroupMemberSpecialTitleOutput;
  const NAME: &'static str = "set_group_member_special_title";
}

/// 设置群管理员
impl ApiEndpoint for SetGroupMemberAdminInput {
  type Output = SetGroupMemberAdminOutput;
  const NAME: &'static str = "set_group_member_admin";
}

/// 设置群成员禁言
impl ApiEndpoint for SetGroupMemberMuteInput {
  type Output = SetGroupMemberMuteOutput;
  const NAME: &'static str = "set_group_member_mute";
}

/// 设置群全员禁言
impl ApiEndpoint for SetGroupWholeMuteInput {
  type Output = SetGroupWholeMuteOutput;
  const NAME: &'static str = "set_group_whole_mute";
}

/// 踢出群成员
impl ApiEndpoint for KickGroupMemberInput {
  type Output = KickGroupMemberOutput;
  const NAME: &'static str = "kick_group_member";
}

/// 获取群公告列表
impl ApiEndpoint for GetGroupAnnouncementsInput {
  type Output = GetGroupAnnouncementsOutput;
  const NAME: &'static str = "get_group_announcements";
}

/// 发送群公告
impl ApiEndpoint for SendGroupAnnouncementInput {
  type Output = SendGroupAnnouncementOutput;
  const NAME: &'static str = "send_group_announcement";
}

/// 删除群公告
impl ApiEndpoint for DeleteGroupAnnouncementInput {
  type Output = DeleteGroupAnnouncementOutput;
  const NAME: &'static str = "delete_group_announcement";
}

/// 获取群精华消息列表
impl ApiEndpoint for GetGroupEssenceMessagesInput {
  type Output = GetGroupEssenceMessagesOutput;
  const NAME: &'static str = "get_group_essence_messages";
}

/// 设置群精华消息
impl ApiEndpoint for SetGroupEssenceMessageInput {
  type Output = SetGroupEssenceMessageOutput;
  const NAME: &'static str = "set_group_essence_message";
}

/// 退出群
impl ApiEndpoint for QuitGroupInput {
  type Output = QuitGroupOutput;
  const NAME: &'static str = "quit_group";
}

/// 发送群消息表情回应
impl ApiEndpoint for SendGroupMessageReactionInput {
  type Output = SendGroupMessageReactionOutput;
  const NAME: &'static str = "send_group_message_reaction";
}

/// 发送群戳一戳
impl ApiEndpoint for SendGroupNudgeInput {
  type Output = SendGroupNudgeOutput;
  const NAME: &'static str = "send_group_nudge";
}

/// 获取群通知列表
impl ApiEndpoint for GetGroupNotificationsInput {
  type Output = GetGroupNotificationsOutput;
  const NAME: &'static str = "get_group_notifications";
}

/// 同意入群/邀请他人入群请求
impl ApiEndpoint for AcceptGroupRequestInput {
  type Output = AcceptGroupRequestOutput;
  const NAME: &'static str = "accept_group_request";
}

/// 拒绝入群/邀请他人入群请求
impl ApiEndpoint for RejectGroupRequestInput {
  type Output = RejectGroupRequestOutput;
  const NAME: &'static str = "reject_group_request";
}

/// 同意他人邀请自身入群
impl ApiEndpoint for AcceptGroupInvitationInput {
  type Output = AcceptGroupInvitationOutput;
  const NAME: &'static str = "accept_group_invitation";
}

/// 拒绝他人邀请自身入群
impl ApiEndpoint for RejectGroupInvitationInput {
  type Output = RejectGroupInvitationOutput;
  const NAME: &'static str = "reject_group_invitation";
}

/// 上传私聊文件
impl ApiEndpoint for UploadPrivateFileInput {
  type Output = UploadPrivateFileOutput;
  const NAME: &'static str = "upload_private_file";
}

/// 上传群文件
impl ApiEndpoint for UploadGroupFileInput {
  type Output = UploadGroupFileOutput;
  const NAME: &'static str = "upload_group_file";
}

/// 获取私聊文件下载链接
impl ApiEndpoint for GetPrivateFileDownloadUrlInput {
  type Output = GetPrivateFileDownloadUrlOutput;
  const NAME: &'static str = "get_private_file_download_url";
}

/// 获取群文件下载链接
impl ApiEndpoint for GetGroupFileDownloadUrlInput {
  type Output = GetGroupFileDownloadUrlOutput;
  const NAME: &'static str = "get_group_file_download_url";
}

/// 获取群文件列表
impl ApiEndpoint for GetGroupFilesInput {
  type Output = GetGroupFilesOutput;
  const NAME: &'static str = "get_group_files";
}

/// 移动群文件
impl ApiEndpoint for MoveGroupFileInput {
  type Output = MoveGroupFileOutput;
  const NAME: &'static str = "move_group_file";
}

/// 重命名群文件
impl ApiEndpoint for RenameGroupFileInput {
  type Output = RenameGroupFileOutput;
  const NAME: &'static str = "rename_group_file";
}

/// 删除群文件
impl ApiEndpoint for DeleteGroupFileInput {
  type Output = DeleteGroupFileOutput;
  const NAME: &'static str = "delete_group_file";
}

/// 创建群文件夹
impl ApiEndpoint for CreateGroupFolderInput {
  type Output = CreateGroupFolderOutput;
  const NAME: &'static str = "create_group_folder";
}

/// 重命名群文件夹
impl ApiEndpoint for RenameGroupFolderInput {
  type Output = RenameGroupFolderOutput;
  const NAME: &'static str = "rename_group_folder";
}

/// 删除群文件夹
impl ApiEndpoint for DeleteGroupFolderInput {
  type Output = DeleteGroupFolderOutput;
  const NAME: &'static str = "delete_group_folder";
}