1#![allow(clippy::option_option)]
8
9use serde::de::Error as DeError;
10use serde::Serialize;
11
12use crate::constants::Opcode;
13use crate::model::prelude::*;
14use crate::model::utils::{
15 deserialize_val,
16 emojis,
17 members,
18 remove_from_map,
19 remove_from_map_opt,
20 stickers,
21};
22
23#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
27#[derive(Clone, Debug, Deserialize, Serialize)]
28#[serde(transparent)]
29#[non_exhaustive]
30pub struct CommandPermissionsUpdateEvent {
31 pub permission: CommandPermissions,
32}
33
34#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
38#[derive(Clone, Debug, Deserialize, Serialize)]
39#[serde(transparent)]
40#[non_exhaustive]
41pub struct AutoModRuleCreateEvent {
42 pub rule: Rule,
43}
44
45#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
49#[derive(Clone, Debug, Deserialize, Serialize)]
50#[serde(transparent)]
51#[non_exhaustive]
52pub struct AutoModRuleUpdateEvent {
53 pub rule: Rule,
54}
55
56#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
60#[derive(Clone, Debug, Deserialize, Serialize)]
61#[serde(transparent)]
62#[non_exhaustive]
63pub struct AutoModRuleDeleteEvent {
64 pub rule: Rule,
65}
66
67#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
71#[derive(Clone, Debug, Deserialize, Serialize)]
72#[serde(transparent)]
73#[non_exhaustive]
74pub struct AutoModActionExecutionEvent {
75 pub execution: ActionExecution,
76}
77
78#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
87#[derive(Clone, Debug, Deserialize, Serialize)]
88#[serde(transparent)]
89#[non_exhaustive]
90pub struct ChannelCreateEvent {
91 pub channel: GuildChannel,
93}
94
95#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
99#[derive(Clone, Debug, Deserialize, Serialize)]
100#[serde(transparent)]
101#[non_exhaustive]
102pub struct ChannelDeleteEvent {
103 pub channel: GuildChannel,
104}
105
106#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
110#[derive(Clone, Debug, Deserialize, Serialize)]
111#[non_exhaustive]
112pub struct ChannelPinsUpdateEvent {
113 pub guild_id: Option<GuildId>,
114 pub channel_id: ChannelId,
115 pub last_pin_timestamp: Option<Timestamp>,
116}
117
118#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
122#[derive(Clone, Debug, Deserialize, Serialize)]
123#[serde(transparent)]
124#[non_exhaustive]
125pub struct ChannelUpdateEvent {
126 pub channel: GuildChannel,
127}
128
129#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
133#[derive(Clone, Debug, Deserialize, Serialize)]
134#[non_exhaustive]
135pub struct GuildAuditLogEntryCreateEvent {
136 pub guild_id: GuildId,
137 #[serde(flatten)]
138 pub entry: AuditLogEntry,
139}
140
141#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
145#[derive(Clone, Debug, Deserialize, Serialize)]
146#[non_exhaustive]
147pub struct GuildBanAddEvent {
148 pub guild_id: GuildId,
149 pub user: User,
150}
151
152#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
156#[derive(Clone, Debug, Deserialize, Serialize)]
157#[non_exhaustive]
158pub struct GuildBanRemoveEvent {
159 pub guild_id: GuildId,
160 pub user: User,
161}
162
163#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
167#[derive(Clone, Debug, Serialize)]
168#[serde(transparent)]
169#[non_exhaustive]
170pub struct GuildCreateEvent {
171 pub guild: Guild,
172}
173
174impl<'de> Deserialize<'de> for GuildCreateEvent {
176 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
177 let mut guild: Guild = Guild::deserialize(deserializer)?;
178 guild.channels.values_mut().for_each(|x| x.guild_id = guild.id);
179 guild.members.values_mut().for_each(|x| x.guild_id = guild.id);
180 guild.roles.values_mut().for_each(|x| x.guild_id = guild.id);
181 Ok(Self {
182 guild,
183 })
184 }
185}
186
187#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
191#[derive(Clone, Debug, Deserialize, Serialize)]
192#[serde(transparent)]
193#[non_exhaustive]
194pub struct GuildDeleteEvent {
195 pub guild: UnavailableGuild,
196}
197
198#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
202#[derive(Clone, Debug, Deserialize, Serialize)]
203#[non_exhaustive]
204pub struct GuildEmojisUpdateEvent {
205 #[serde(with = "emojis")]
206 pub emojis: HashMap<EmojiId, Emoji>,
207 pub guild_id: GuildId,
208}
209
210#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
214#[derive(Clone, Debug, Deserialize, Serialize)]
215#[non_exhaustive]
216pub struct GuildIntegrationsUpdateEvent {
217 pub guild_id: GuildId,
218}
219
220#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
224#[derive(Clone, Debug, Deserialize, Serialize)]
225#[serde(transparent)]
226#[non_exhaustive]
227pub struct GuildMemberAddEvent {
228 pub member: Member,
229}
230
231#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
235#[derive(Clone, Debug, Deserialize, Serialize)]
236#[non_exhaustive]
237pub struct GuildMemberRemoveEvent {
238 pub guild_id: GuildId,
239 pub user: User,
240}
241
242#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
246#[derive(Clone, Debug, Deserialize, Serialize)]
247#[non_exhaustive]
248pub struct GuildMemberUpdateEvent {
249 pub guild_id: GuildId,
250 pub nick: Option<String>,
251 pub joined_at: Timestamp,
252 pub roles: Vec<RoleId>,
253 pub user: User,
254 pub premium_since: Option<Timestamp>,
255 #[serde(default)]
256 pub pending: bool,
257 #[serde(default)]
258 pub deaf: bool,
259 #[serde(default)]
260 pub mute: bool,
261 pub avatar: Option<ImageHash>,
262 pub communication_disabled_until: Option<Timestamp>,
263 pub unusual_dm_activity_until: Option<Timestamp>,
264}
265
266#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
270#[derive(Clone, Debug, Deserialize, Serialize)]
271#[serde(remote = "Self")]
272#[non_exhaustive]
273pub struct GuildMembersChunkEvent {
274 pub guild_id: GuildId,
276 #[serde(with = "members")]
278 pub members: HashMap<UserId, Member>,
279 pub chunk_index: u32,
281 pub chunk_count: u32,
283 #[serde(default)]
286 pub not_found: Vec<GenericId>,
287 pub presences: Option<Vec<Presence>>,
290 pub nonce: Option<String>,
292}
293
294impl<'de> Deserialize<'de> for GuildMembersChunkEvent {
296 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
297 let mut event = Self::deserialize(deserializer)?; event.members.values_mut().for_each(|m| m.guild_id = event.guild_id);
299 Ok(event)
300 }
301}
302
303impl Serialize for GuildMembersChunkEvent {
304 fn serialize<S: serde::Serializer>(&self, serializer: S) -> StdResult<S::Ok, S::Error> {
305 Self::serialize(self, serializer) }
307}
308
309#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
311#[derive(Deserialize)]
312struct RoleEventHelper {
313 guild_id: GuildId,
314 role: Role,
315}
316
317#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
321#[derive(Clone, Debug, Serialize)]
322#[non_exhaustive]
323pub struct GuildRoleCreateEvent {
324 pub role: Role,
325}
326
327impl<'de> Deserialize<'de> for GuildRoleCreateEvent {
329 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
330 let mut event = RoleEventHelper::deserialize(deserializer)?;
331 event.role.guild_id = event.guild_id;
332 Ok(Self {
333 role: event.role,
334 })
335 }
336}
337
338#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
342#[derive(Clone, Debug, Deserialize, Serialize)]
343#[non_exhaustive]
344pub struct GuildRoleDeleteEvent {
345 pub guild_id: GuildId,
346 pub role_id: RoleId,
347}
348
349#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
353#[derive(Clone, Debug, Serialize)]
354#[non_exhaustive]
355pub struct GuildRoleUpdateEvent {
356 pub role: Role,
357}
358
359impl<'de> Deserialize<'de> for GuildRoleUpdateEvent {
361 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
362 let mut event = RoleEventHelper::deserialize(deserializer)?;
363 event.role.guild_id = event.guild_id;
364 Ok(Self {
365 role: event.role,
366 })
367 }
368}
369
370#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
374#[derive(Clone, Debug, Deserialize, Serialize)]
375#[non_exhaustive]
376pub struct GuildStickersUpdateEvent {
377 #[serde(with = "stickers")]
378 pub stickers: HashMap<StickerId, Sticker>,
379 pub guild_id: GuildId,
380}
381
382#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
386#[derive(Clone, Debug, Deserialize, Serialize)]
387#[non_exhaustive]
388pub struct InviteCreateEvent {
389 pub channel_id: ChannelId,
392 pub code: String,
394 pub created_at: Timestamp,
396 pub guild_id: Option<GuildId>,
398 pub inviter: Option<User>,
400 pub max_age: u32,
402 pub max_uses: u8,
404 pub target_type: Option<InviteTargetType>,
406 pub target_user: Option<User>,
408 pub target_application: Option<Value>,
410 pub temporary: bool,
412 pub uses: u64,
414}
415
416#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
420#[derive(Clone, Debug, Deserialize, Serialize)]
421#[non_exhaustive]
422pub struct InviteDeleteEvent {
423 pub channel_id: ChannelId,
424 pub guild_id: Option<GuildId>,
425 pub code: String,
426}
427
428#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
432#[derive(Clone, Debug, Deserialize, Serialize)]
433#[serde(transparent)]
434#[non_exhaustive]
435pub struct GuildUpdateEvent {
436 pub guild: PartialGuild,
438}
439
440#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
444#[derive(Clone, Debug, Deserialize, Serialize)]
445#[serde(transparent)]
446#[non_exhaustive]
447pub struct MessageCreateEvent {
448 pub message: Message,
449}
450
451#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
455#[derive(Clone, Debug, Deserialize, Serialize)]
456#[non_exhaustive]
457pub struct MessageDeleteBulkEvent {
458 pub guild_id: Option<GuildId>,
459 pub channel_id: ChannelId,
460 pub ids: Vec<MessageId>,
461}
462
463#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
467#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
468#[non_exhaustive]
469pub struct MessageDeleteEvent {
470 pub guild_id: Option<GuildId>,
471 pub channel_id: ChannelId,
472 #[serde(rename = "id")]
473 pub message_id: MessageId,
474}
475
476fn deserialize_some<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
479where
480 T: Deserialize<'de>,
481 D: Deserializer<'de>,
482{
483 Deserialize::deserialize(deserializer).map(Some)
484}
485
486#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
495#[derive(Clone, Debug, Deserialize, Serialize)]
496#[non_exhaustive]
497pub struct MessageUpdateEvent {
498 pub id: MessageId,
499 pub channel_id: ChannelId,
500 pub author: Option<User>,
501 pub content: Option<String>,
502 pub timestamp: Option<Timestamp>,
503 pub edited_timestamp: Option<Timestamp>,
504 pub tts: Option<bool>,
505 pub mention_everyone: Option<bool>,
506 pub mentions: Option<Vec<User>>,
507 pub mention_roles: Option<Vec<RoleId>>,
508 pub mention_channels: Option<Vec<ChannelMention>>,
509 pub attachments: Option<Vec<Attachment>>,
510 pub embeds: Option<Vec<Embed>>,
511 pub reactions: Option<Vec<MessageReaction>>,
512 pub pinned: Option<bool>,
513 #[serde(default, deserialize_with = "deserialize_some")]
514 pub webhook_id: Option<Option<WebhookId>>,
515 #[serde(rename = "type")]
516 pub kind: Option<MessageType>,
517 #[serde(default, deserialize_with = "deserialize_some")]
518 pub activity: Option<Option<MessageActivity>>,
519 #[serde(default, deserialize_with = "deserialize_some")]
520 pub application: Option<Option<MessageApplication>>,
521 #[serde(default, deserialize_with = "deserialize_some")]
522 pub application_id: Option<Option<ApplicationId>>,
523 pub message_reference: Option<Option<MessageReference>>,
524 #[serde(default, deserialize_with = "deserialize_some")]
525 pub flags: Option<Option<MessageFlags>>,
526 #[serde(default, deserialize_with = "deserialize_some")]
527 pub referenced_message: Option<Option<Box<Message>>>,
528 #[cfg_attr(not(ignore_serenity_deprecated), deprecated = "Use interaction_metadata")]
529 #[serde(default, deserialize_with = "deserialize_some")]
530 pub interaction: Option<Option<Box<MessageInteraction>>>,
531 pub interaction_metadata: Option<Option<Box<MessageInteractionMetadata>>>,
532 #[serde(default, deserialize_with = "deserialize_some")]
533 pub thread: Option<Option<GuildChannel>>,
534 pub components: Option<Vec<ActionRow>>,
535 pub sticker_items: Option<Vec<StickerItem>>,
536 pub position: Option<Option<u64>>,
537 pub role_subscription_data: Option<Option<RoleSubscriptionData>>,
538 pub guild_id: Option<GuildId>,
539 pub member: Option<Option<Box<PartialMember>>>,
540}
541
542impl MessageUpdateEvent {
543 #[allow(clippy::clone_on_copy)] #[rustfmt::skip]
545 pub fn apply_to_message(&self, message: &mut Message) {
547 #[allow(deprecated)] let Self {
551 id,
552 channel_id,
553 author,
554 content,
555 timestamp,
556 edited_timestamp,
557 tts,
558 mention_everyone,
559 mentions,
560 mention_roles,
561 mention_channels,
562 attachments,
563 embeds,
564 reactions,
565 pinned,
566 webhook_id,
567 kind,
568 activity,
569 application,
570 application_id,
571 message_reference,
572 flags,
573 referenced_message,
574 interaction,
575 interaction_metadata,
576 thread,
577 components,
578 sticker_items,
579 position,
580 role_subscription_data,
581 guild_id,
582 member,
583 } = self;
584
585 message.id = *id;
589 message.channel_id = *channel_id;
590
591 if let Some(x) = author { message.author = x.clone() }
592 if let Some(x) = content { message.content.clone_from(x) }
593 if let Some(x) = timestamp { message.timestamp = x.clone() }
594 message.edited_timestamp = *edited_timestamp;
595 if let Some(x) = tts { message.tts = x.clone() }
596 if let Some(x) = mention_everyone { message.mention_everyone = x.clone() }
597 if let Some(x) = mentions { message.mentions.clone_from(x) }
598 if let Some(x) = mention_roles { message.mention_roles.clone_from(x) }
599 if let Some(x) = mention_channels { message.mention_channels.clone_from(x) }
600 if let Some(x) = attachments { message.attachments.clone_from(x) }
601 if let Some(x) = embeds { message.embeds.clone_from(x) }
602 if let Some(x) = reactions { message.reactions.clone_from(x) }
603 if let Some(x) = pinned { message.pinned = x.clone() }
604 if let Some(x) = webhook_id { message.webhook_id.clone_from(x) }
605 if let Some(x) = kind { message.kind = x.clone() }
606 if let Some(x) = activity { message.activity.clone_from(x) }
607 if let Some(x) = application { message.application.clone_from(x) }
608 if let Some(x) = application_id { message.application_id.clone_from(x) }
609 if let Some(x) = message_reference { message.message_reference.clone_from(x) }
610 if let Some(x) = flags { message.flags.clone_from(x) }
611 if let Some(x) = referenced_message { message.referenced_message.clone_from(x) }
612 if let Some(x) = interaction { message.interaction.clone_from(x) }
613 if let Some(x) = interaction_metadata { message.interaction_metadata.clone_from(x) }
614 if let Some(x) = thread { message.thread.clone_from(x) }
615 if let Some(x) = components { message.components.clone_from(x) }
616 if let Some(x) = sticker_items { message.sticker_items.clone_from(x) }
617 if let Some(x) = position { message.position.clone_from(x) }
618 if let Some(x) = role_subscription_data { message.role_subscription_data.clone_from(x) }
619 message.guild_id = *guild_id;
620 if let Some(x) = member { message.member.clone_from(x) }
621 }
622}
623
624#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
628#[derive(Clone, Debug, Deserialize, Serialize)]
629#[serde(transparent)]
630#[non_exhaustive]
631pub struct PresenceUpdateEvent {
632 pub presence: Presence,
633}
634
635#[cfg_attr(not(ignore_serenity_deprecated), deprecated = "This event doesn't exist")]
637#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
638#[derive(Clone, Debug, Deserialize, Serialize)]
639#[serde(transparent)]
640#[non_exhaustive]
641pub struct PresencesReplaceEvent {
642 pub presences: Vec<Presence>,
643}
644
645#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
650#[derive(Clone, Debug, Deserialize, Serialize)]
651#[serde(transparent)]
652#[non_exhaustive]
653pub struct ReactionAddEvent {
654 pub reaction: Reaction,
655}
656
657#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
662#[derive(Clone, Debug, Deserialize, Serialize)]
663#[serde(transparent)]
664#[non_exhaustive]
665pub struct ReactionRemoveEvent {
666 pub reaction: Reaction,
670}
671
672#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
677#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
678#[non_exhaustive]
679pub struct ReactionRemoveAllEvent {
680 pub channel_id: ChannelId,
681 pub message_id: MessageId,
682 pub guild_id: Option<GuildId>,
683}
684
685#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
690#[derive(Clone, Debug, Deserialize, Serialize)]
691#[serde(transparent)]
692#[non_exhaustive]
693pub struct ReactionRemoveEmojiEvent {
694 pub reaction: Reaction,
695}
696
697#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
703#[derive(Clone, Debug, Deserialize, Serialize)]
704#[serde(transparent)]
705#[non_exhaustive]
706pub struct ReadyEvent {
707 pub ready: Ready,
708}
709
710#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
714#[derive(Clone, Debug, Deserialize, Serialize)]
715#[non_exhaustive]
716pub struct ResumedEvent {}
717
718#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
722#[derive(Clone, Debug, Deserialize, Serialize)]
723#[non_exhaustive]
724pub struct TypingStartEvent {
725 pub channel_id: ChannelId,
727 pub guild_id: Option<GuildId>,
729 pub user_id: UserId,
731 pub timestamp: u64,
733 pub member: Option<Member>,
735}
736
737#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
738#[derive(Clone, Debug, Deserialize, Serialize)]
739#[non_exhaustive]
740pub struct UnknownEvent {
741 #[serde(rename = "t")]
742 pub kind: String,
743 #[serde(rename = "d")]
744 pub value: Value,
745}
746
747#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
753#[derive(Clone, Debug, Deserialize, Serialize)]
754#[serde(transparent)]
755#[non_exhaustive]
756pub struct UserUpdateEvent {
757 pub current_user: CurrentUser,
758}
759
760#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
764#[derive(Clone, Debug, Deserialize, Serialize)]
765#[non_exhaustive]
766pub struct VoiceServerUpdateEvent {
767 pub token: String,
768 pub guild_id: Option<GuildId>,
769 pub endpoint: Option<String>,
770}
771
772#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
776#[derive(Clone, Debug, Deserialize, Serialize)]
777#[serde(transparent)]
778#[non_exhaustive]
779pub struct VoiceStateUpdateEvent {
780 pub voice_state: VoiceState,
781}
782
783#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
787#[derive(Clone, Debug, Deserialize, Serialize)]
788#[non_exhaustive]
789pub struct VoiceChannelStatusUpdateEvent {
790 pub status: Option<String>,
791 pub id: ChannelId,
792 pub guild_id: GuildId,
793}
794
795#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
799#[derive(Clone, Debug, Deserialize, Serialize)]
800#[non_exhaustive]
801pub struct WebhookUpdateEvent {
802 pub channel_id: ChannelId,
803 pub guild_id: GuildId,
804}
805
806#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
810#[derive(Clone, Debug, Deserialize, Serialize)]
811#[serde(transparent)]
812#[non_exhaustive]
813pub struct InteractionCreateEvent {
814 pub interaction: Interaction,
815}
816
817#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
821#[derive(Clone, Debug, Deserialize, Serialize)]
822#[serde(transparent)]
823#[non_exhaustive]
824pub struct IntegrationCreateEvent {
825 pub integration: Integration,
826}
827
828#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
832#[derive(Clone, Debug, Deserialize, Serialize)]
833#[serde(transparent)]
834#[non_exhaustive]
835pub struct IntegrationUpdateEvent {
836 pub integration: Integration,
837}
838
839#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
843#[derive(Clone, Debug, Serialize, Deserialize)]
844#[non_exhaustive]
845pub struct IntegrationDeleteEvent {
846 pub id: IntegrationId,
847 pub guild_id: GuildId,
848 pub application_id: Option<ApplicationId>,
849}
850
851#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
855#[derive(Clone, Debug, Deserialize, Serialize)]
856#[serde(transparent)]
857#[non_exhaustive]
858pub struct StageInstanceCreateEvent {
859 pub stage_instance: StageInstance,
860}
861
862#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
866#[derive(Clone, Debug, Deserialize, Serialize)]
867#[serde(transparent)]
868#[non_exhaustive]
869pub struct StageInstanceUpdateEvent {
870 pub stage_instance: StageInstance,
871}
872
873#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
877#[derive(Clone, Debug, Deserialize, Serialize)]
878#[serde(transparent)]
879#[non_exhaustive]
880pub struct StageInstanceDeleteEvent {
881 pub stage_instance: StageInstance,
882}
883
884#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
888#[derive(Clone, Debug, Deserialize, Serialize)]
889#[serde(transparent)]
890#[non_exhaustive]
891pub struct ThreadCreateEvent {
892 pub thread: GuildChannel,
893}
894
895#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
899#[derive(Clone, Debug, Deserialize, Serialize)]
900#[serde(transparent)]
901#[non_exhaustive]
902pub struct ThreadUpdateEvent {
903 pub thread: GuildChannel,
904}
905
906#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
910#[derive(Clone, Debug, Deserialize, Serialize)]
911#[serde(transparent)]
912#[non_exhaustive]
913pub struct ThreadDeleteEvent {
914 pub thread: PartialGuildChannel,
915}
916
917#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
921#[derive(Clone, Debug, Deserialize, Serialize)]
922#[non_exhaustive]
923pub struct ThreadListSyncEvent {
924 pub guild_id: GuildId,
926 pub channel_ids: Option<Vec<ChannelId>>,
930 pub threads: Vec<GuildChannel>,
932 pub members: Vec<ThreadMember>,
935}
936
937#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
942#[derive(Clone, Debug, Deserialize, Serialize)]
943#[serde(transparent)]
944#[non_exhaustive]
945pub struct ThreadMemberUpdateEvent {
946 pub member: ThreadMember,
947}
948
949#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
953#[derive(Clone, Debug, Deserialize, Serialize)]
954#[non_exhaustive]
955pub struct ThreadMembersUpdateEvent {
956 pub id: ChannelId,
958 pub guild_id: GuildId,
960 pub member_count: i16,
965 #[serde(default)]
967 pub added_members: Vec<ThreadMember>,
968 #[serde(default)]
970 pub removed_member_ids: Vec<UserId>,
971}
972
973#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
977#[derive(Clone, Debug, Deserialize, Serialize)]
978#[serde(transparent)]
979#[non_exhaustive]
980pub struct GuildScheduledEventCreateEvent {
981 pub event: ScheduledEvent,
982}
983
984#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
988#[derive(Clone, Debug, Deserialize, Serialize)]
989#[serde(transparent)]
990#[non_exhaustive]
991pub struct GuildScheduledEventUpdateEvent {
992 pub event: ScheduledEvent,
993}
994
995#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
999#[derive(Clone, Debug, Deserialize, Serialize)]
1000#[serde(transparent)]
1001#[non_exhaustive]
1002pub struct GuildScheduledEventDeleteEvent {
1003 pub event: ScheduledEvent,
1004}
1005
1006#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
1010#[derive(Clone, Debug, Deserialize, Serialize)]
1011#[non_exhaustive]
1012pub struct GuildScheduledEventUserAddEvent {
1013 #[serde(rename = "guild_scheduled_event_id")]
1014 pub scheduled_event_id: ScheduledEventId,
1015 pub user_id: UserId,
1016 pub guild_id: GuildId,
1017}
1018
1019#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
1023#[derive(Clone, Debug, Deserialize, Serialize)]
1024#[non_exhaustive]
1025pub struct GuildScheduledEventUserRemoveEvent {
1026 #[serde(rename = "guild_scheduled_event_id")]
1027 pub scheduled_event_id: ScheduledEventId,
1028 pub user_id: UserId,
1029 pub guild_id: GuildId,
1030}
1031
1032#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
1036#[derive(Clone, Debug, Deserialize, Serialize)]
1037#[serde(transparent)]
1038#[non_exhaustive]
1039pub struct EntitlementCreateEvent {
1040 pub entitlement: Entitlement,
1041}
1042
1043#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
1047#[derive(Clone, Debug, Deserialize, Serialize)]
1048#[serde(transparent)]
1049#[non_exhaustive]
1050pub struct EntitlementUpdateEvent {
1051 pub entitlement: Entitlement,
1052}
1053
1054#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
1058#[derive(Clone, Debug, Deserialize, Serialize)]
1059#[serde(transparent)]
1060#[non_exhaustive]
1061pub struct EntitlementDeleteEvent {
1062 pub entitlement: Entitlement,
1063}
1064
1065#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
1069#[derive(Clone, Debug, Deserialize, Serialize)]
1070#[non_exhaustive]
1071pub struct MessagePollVoteAddEvent {
1072 pub user_id: UserId,
1073 pub channel_id: ChannelId,
1074 pub message_id: MessageId,
1075 pub guild_id: Option<GuildId>,
1076 pub answer_id: AnswerId,
1077}
1078
1079#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
1083#[derive(Clone, Debug, Deserialize, Serialize)]
1084#[non_exhaustive]
1085pub struct MessagePollVoteRemoveEvent {
1086 pub user_id: UserId,
1087 pub channel_id: ChannelId,
1088 pub message_id: MessageId,
1089 pub guild_id: Option<GuildId>,
1090 pub answer_id: AnswerId,
1091}
1092
1093#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
1095#[allow(clippy::large_enum_variant)]
1096#[derive(Debug, Clone, Serialize)]
1097#[non_exhaustive]
1098#[serde(untagged)]
1099pub enum GatewayEvent {
1100 Dispatch(u64, Event),
1101 Heartbeat(u64),
1102 Reconnect,
1103 InvalidateSession(bool),
1105 Hello(u64),
1106 HeartbeatAck,
1107}
1108
1109impl<'de> Deserialize<'de> for GatewayEvent {
1111 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
1112 let mut map = JsonMap::deserialize(deserializer)?;
1113 let seq = remove_from_map_opt(&mut map, "s")?.flatten();
1114
1115 Ok(match remove_from_map(&mut map, "op")? {
1116 Opcode::Dispatch => Self::Dispatch(
1117 seq.ok_or_else(|| DeError::missing_field("s"))?,
1118 deserialize_val(Value::from(map))?,
1119 ),
1120 Opcode::Heartbeat => {
1121 GatewayEvent::Heartbeat(seq.ok_or_else(|| DeError::missing_field("s"))?)
1122 },
1123 Opcode::InvalidSession => {
1124 GatewayEvent::InvalidateSession(remove_from_map(&mut map, "d")?)
1125 },
1126 Opcode::Hello => {
1127 #[derive(Deserialize)]
1128 struct HelloPayload {
1129 heartbeat_interval: u64,
1130 }
1131
1132 let inner: HelloPayload = remove_from_map(&mut map, "d")?;
1133 GatewayEvent::Hello(inner.heartbeat_interval)
1134 },
1135 Opcode::Reconnect => GatewayEvent::Reconnect,
1136 Opcode::HeartbeatAck => GatewayEvent::HeartbeatAck,
1137 _ => return Err(DeError::custom("invalid opcode")),
1138 })
1139 }
1140}
1141
1142#[allow(clippy::large_enum_variant)]
1146#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
1147#[derive(Clone, Debug, Deserialize, Serialize)]
1148#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
1149#[serde(tag = "t", content = "d")]
1150#[non_exhaustive]
1151pub enum Event {
1152 #[serde(rename = "APPLICATION_COMMAND_PERMISSIONS_UPDATE")]
1159 CommandPermissionsUpdate(CommandPermissionsUpdateEvent),
1160 #[serde(rename = "AUTO_MODERATION_RULE_CREATE")]
1167 AutoModRuleCreate(AutoModRuleCreateEvent),
1168 #[serde(rename = "AUTO_MODERATION_RULE_UPDATE")]
1175 AutoModRuleUpdate(AutoModRuleUpdateEvent),
1176 #[serde(rename = "AUTO_MODERATION_RULE_DELETE")]
1183 AutoModRuleDelete(AutoModRuleDeleteEvent),
1184 #[serde(rename = "AUTO_MODERATION_ACTION_EXECUTION")]
1191 AutoModActionExecution(AutoModActionExecutionEvent),
1192 ChannelCreate(ChannelCreateEvent),
1198 ChannelDelete(ChannelDeleteEvent),
1204 ChannelPinsUpdate(ChannelPinsUpdateEvent),
1210 ChannelUpdate(ChannelUpdateEvent),
1216 GuildAuditLogEntryCreate(GuildAuditLogEntryCreateEvent),
1217 GuildBanAdd(GuildBanAddEvent),
1218 GuildBanRemove(GuildBanRemoveEvent),
1219 GuildCreate(GuildCreateEvent),
1220 GuildDelete(GuildDeleteEvent),
1221 GuildEmojisUpdate(GuildEmojisUpdateEvent),
1222 GuildIntegrationsUpdate(GuildIntegrationsUpdateEvent),
1223 GuildMemberAdd(GuildMemberAddEvent),
1224 GuildMemberRemove(GuildMemberRemoveEvent),
1225 GuildMemberUpdate(GuildMemberUpdateEvent),
1227 GuildMembersChunk(GuildMembersChunkEvent),
1228 GuildRoleCreate(GuildRoleCreateEvent),
1229 GuildRoleDelete(GuildRoleDeleteEvent),
1230 GuildRoleUpdate(GuildRoleUpdateEvent),
1231 GuildStickersUpdate(GuildStickersUpdateEvent),
1233 GuildUpdate(GuildUpdateEvent),
1234 InviteCreate(InviteCreateEvent),
1240 InviteDelete(InviteDeleteEvent),
1246 MessageCreate(MessageCreateEvent),
1247 MessageDelete(MessageDeleteEvent),
1248 MessageDeleteBulk(MessageDeleteBulkEvent),
1249 MessageUpdate(MessageUpdateEvent),
1251 PresenceUpdate(PresenceUpdateEvent),
1253 #[cfg_attr(not(ignore_serenity_deprecated), deprecated = "This event doesn't exist")]
1255 PresencesReplace(PresencesReplaceEvent),
1256 #[serde(rename = "MESSAGE_REACTION_ADD")]
1262 ReactionAdd(ReactionAddEvent),
1263 #[serde(rename = "MESSAGE_REACTION_REMOVE")]
1269 ReactionRemove(ReactionRemoveEvent),
1270 #[serde(rename = "MESSAGE_REACTION_REMOVE_ALL")]
1276 ReactionRemoveAll(ReactionRemoveAllEvent),
1277 #[serde(rename = "MESSAGE_REACTION_REMOVE_EMOJI")]
1283 ReactionRemoveEmoji(ReactionRemoveEmojiEvent),
1284 Ready(ReadyEvent),
1288 Resumed(ResumedEvent),
1290 TypingStart(TypingStartEvent),
1292 UserUpdate(UserUpdateEvent),
1294 VoiceStateUpdate(VoiceStateUpdateEvent),
1296 VoiceServerUpdate(VoiceServerUpdateEvent),
1298 VoiceChannelStatusUpdate(VoiceChannelStatusUpdateEvent),
1300 #[serde(rename = "WEBHOOKS_UPDATE")]
1302 WebhookUpdate(WebhookUpdateEvent),
1303 InteractionCreate(InteractionCreateEvent),
1305 IntegrationCreate(IntegrationCreateEvent),
1307 IntegrationUpdate(IntegrationUpdateEvent),
1309 IntegrationDelete(IntegrationDeleteEvent),
1311 StageInstanceCreate(StageInstanceCreateEvent),
1313 StageInstanceUpdate(StageInstanceUpdateEvent),
1315 StageInstanceDelete(StageInstanceDeleteEvent),
1317 ThreadCreate(ThreadCreateEvent),
1320 ThreadUpdate(ThreadUpdateEvent),
1322 ThreadDelete(ThreadDeleteEvent),
1324 ThreadListSync(ThreadListSyncEvent),
1326 ThreadMemberUpdate(ThreadMemberUpdateEvent),
1328 ThreadMembersUpdate(ThreadMembersUpdateEvent),
1330 GuildScheduledEventCreate(GuildScheduledEventCreateEvent),
1332 GuildScheduledEventUpdate(GuildScheduledEventUpdateEvent),
1334 GuildScheduledEventDelete(GuildScheduledEventDeleteEvent),
1336 GuildScheduledEventUserAdd(GuildScheduledEventUserAddEvent),
1338 GuildScheduledEventUserRemove(GuildScheduledEventUserRemoveEvent),
1340 EntitlementCreate(EntitlementCreateEvent),
1342 EntitlementUpdate(EntitlementUpdateEvent),
1344 EntitlementDelete(EntitlementDeleteEvent),
1346 MessagePollVoteAdd(MessagePollVoteAddEvent),
1348 MessagePollVoteRemove(MessagePollVoteRemoveEvent),
1350 #[serde(untagged)]
1352 Unknown(UnknownEvent),
1353}
1354
1355impl Event {
1356 #[must_use]
1359 pub fn name(&self) -> Option<String> {
1360 if let Self::Unknown(_) = self {
1361 None
1362 } else {
1363 let map = serde_json::to_value(self).ok()?;
1364 Some(map.get("t")?.as_str()?.to_string())
1365 }
1366 }
1367}