diff --git a/src/model/application/component.rs b/src/model/application/component.rs
index 49225611134..51033ef78c6 100644
--- a/src/model/application/component.rs
+++ b/src/model/application/component.rs
@@ -1,8 +1,10 @@
 use serde::de::{Deserialize, Deserializer, Error as DeError};
 use serde::ser::{Serialize, Serializer};
 
-use crate::json::{from_value, JsonMap, Value};
+use crate::internal::prelude::*;
+use crate::json::from_value;
 use crate::model::channel::ReactionType;
+use crate::model::utils::deserialize_val;
 
 /// The type of a component
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, PartialOrd, Ord)]
@@ -44,39 +46,27 @@ pub enum ActionRowComponent {
 }
 
 impl<'de> Deserialize<'de> for ActionRowComponent {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let map = JsonMap::deserialize(deserializer)?;
-
-        let kind = map
-            .get("type")
-            .ok_or_else(|| DeError::custom("expected type"))
-            .and_then(ComponentType::deserialize)
-            .map_err(DeError::custom)?;
-
-        match kind {
-            ComponentType::Button => from_value::<Button>(Value::from(map))
-                .map(ActionRowComponent::Button)
-                .map_err(DeError::custom),
-            ComponentType::SelectMenu => from_value::<SelectMenu>(Value::from(map))
-                .map(ActionRowComponent::SelectMenu)
-                .map_err(DeError::custom),
-            ComponentType::InputText => from_value::<InputText>(Value::from(map))
-                .map(ActionRowComponent::InputText)
-                .map_err(DeError::custom),
-            _ => Err(DeError::custom("Unknown component type")),
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> std::result::Result<Self, D::Error> {
+        let value = Value::deserialize(deserializer)?;
+        let map = value.as_object().ok_or_else(|| DeError::custom("expected JsonMap"))?;
+
+        let raw_kind = map.get("type").ok_or_else(|| DeError::missing_field("type"))?;
+        match deserialize_val(raw_kind.clone())? {
+            ComponentType::Button => from_value(value).map(ActionRowComponent::Button),
+            ComponentType::InputText => from_value(value).map(ActionRowComponent::InputText),
+            ComponentType::SelectMenu => from_value(value).map(ActionRowComponent::SelectMenu),
+            _ => return Err(DeError::custom("Unknown component type")),
         }
+        .map_err(DeError::custom)
     }
 }
 
 impl Serialize for ActionRowComponent {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
+    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
         match self {
-            Self::Button(c) => Button::serialize(c, serializer),
-            Self::SelectMenu(c) => SelectMenu::serialize(c, serializer),
-            Self::InputText(c) => InputText::serialize(c, serializer),
+            Self::Button(c) => c.serialize(serializer),
+            Self::InputText(c) => c.serialize(serializer),
+            Self::SelectMenu(c) => c.serialize(serializer),
         }
     }
 }
diff --git a/src/model/application/interaction/application_command.rs b/src/model/application/interaction/application_command.rs
index 71b262a789e..81db251cebb 100644
--- a/src/model/application/interaction/application_command.rs
+++ b/src/model/application/interaction/application_command.rs
@@ -14,11 +14,10 @@ use crate::http::Http;
 use crate::internal::prelude::*;
 #[cfg(feature = "http")]
 use crate::json;
-use crate::json::prelude::*;
 use crate::model::application::command::{CommandOptionType, CommandType};
 #[cfg(feature = "http")]
 use crate::model::application::interaction::InteractionResponseType;
-use crate::model::application::interaction::InteractionType;
+use crate::model::application::interaction::{add_guild_id_to_resolved, InteractionType};
 use crate::model::channel::{Attachment, Message, PartialChannel};
 use crate::model::guild::{Member, PartialMember, Role};
 use crate::model::id::{
@@ -34,7 +33,11 @@ use crate::model::id::{
     UserId,
 };
 use crate::model::user::User;
-use crate::model::utils::deserialize_options_with_resolved;
+use crate::model::utils::{
+    deserialize_options_with_resolved,
+    remove_from_map,
+    remove_from_map_opt,
+};
 use crate::model::Permissions;
 
 /// An interaction when a user invokes a slash command.
@@ -330,119 +333,31 @@ impl<'de> Deserialize<'de> for ApplicationCommandInteraction {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
-        let id = map.get("guild_id").and_then(Value::as_str).and_then(|x| x.parse::<u64>().ok());
-
-        if let Some(guild_id) = id {
-            if let Some(member) = map.get_mut("member").and_then(Value::as_object_mut) {
-                member.insert("guild_id".to_string(), from_number(guild_id));
-            }
-
-            if let Some(data) = map.get_mut("data") {
-                if let Some(resolved) = data.get_mut("resolved") {
-                    if let Some(roles) = resolved.get_mut("roles") {
-                        if let Some(values) = roles.as_object_mut() {
-                            for value in values.values_mut() {
-                                value.as_object_mut().expect("couldn't deserialize").insert(
-                                    "guild_id".to_string(),
-                                    Value::from(guild_id.to_string()),
-                                );
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        let id = map
-            .remove("id")
-            .ok_or_else(|| DeError::custom("expected id"))
-            .and_then(InteractionId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let application_id = map
-            .remove("application_id")
-            .ok_or_else(|| DeError::custom("expected application id"))
-            .and_then(ApplicationId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let kind = map
-            .remove("type")
-            .ok_or_else(|| DeError::custom("expected type"))
-            .and_then(InteractionType::deserialize)
-            .map_err(DeError::custom)?;
-
-        let data = map
-            .remove("data")
-            .ok_or_else(|| DeError::custom("expected data"))
-            .and_then(CommandData::deserialize)
-            .map_err(DeError::custom)?;
-
-        let guild_id = map
-            .remove("guild_id")
-            .map(GuildId::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let channel_id = map
-            .remove("channel_id")
-            .ok_or_else(|| DeError::custom("expected channel_id"))
-            .and_then(ChannelId::deserialize)
-            .map_err(DeError::custom)?;
+        let guild_id = remove_from_map_opt::<GuildId, _>(&mut map, "guild_id")?;
 
-        let member =
-            map.remove("member").map(Member::deserialize).transpose().map_err(DeError::custom)?;
-
-        let user =
-            map.remove("user").map(User::deserialize).transpose().map_err(DeError::custom)?;
+        if let Some(guild_id) = guild_id {
+            add_guild_id_to_resolved(&mut map, guild_id);
+        }
 
-        let user = user
+        let member = remove_from_map_opt::<Member, _>(&mut map, "member")?;
+        let user = remove_from_map_opt(&mut map, "user")?
             .or_else(|| member.as_ref().map(|m| m.user.clone()))
             .ok_or_else(|| DeError::custom("expected user or member"))?;
 
-        let token = map
-            .remove("token")
-            .ok_or_else(|| DeError::custom("expected token"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
-        let version = map
-            .remove("version")
-            .ok_or_else(|| DeError::custom("expected version"))
-            .and_then(u8::deserialize)
-            .map_err(DeError::custom)?;
-
-        let app_permissions = map
-            .remove("app_permissions")
-            .map(Permissions::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let guild_locale = map
-            .remove("guild_locale")
-            .map(String::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let locale = map
-            .remove("locale")
-            .ok_or_else(|| DeError::custom("expected locale"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
         Ok(Self {
-            id,
-            application_id,
-            kind,
-            data,
             guild_id,
-            channel_id,
             member,
             user,
-            token,
-            version,
-            app_permissions,
-            locale,
-            guild_locale,
+            id: remove_from_map(&mut map, "id")?,
+            application_id: remove_from_map(&mut map, "application_id")?,
+            kind: remove_from_map(&mut map, "type")?,
+            data: remove_from_map(&mut map, "data")?,
+            channel_id: remove_from_map(&mut map, "channel_id")?,
+            token: remove_from_map(&mut map, "token")?,
+            version: remove_from_map(&mut map, "version")?,
+            app_permissions: remove_from_map_opt(&mut map, "app_permissions")?,
+            locale: remove_from_map(&mut map, "locale")?,
+            guild_locale: remove_from_map_opt(&mut map, "guild_locale")?,
         })
     }
 }
@@ -510,24 +425,7 @@ impl<'de> Deserialize<'de> for CommandData {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
-        let name = map
-            .remove("name")
-            .ok_or_else(|| DeError::custom("expected value"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
-        let id = map
-            .remove("id")
-            .ok_or_else(|| DeError::custom("expected value"))
-            .and_then(CommandId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let resolved = map
-            .remove("resolved")
-            .map(CommandDataResolved::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?
-            .unwrap_or_default();
+        let resolved = remove_from_map_opt(&mut map, "resolved")?.unwrap_or_default();
 
         let options = map
             .remove("options")
@@ -536,30 +434,14 @@ impl<'de> Deserialize<'de> for CommandData {
             .map_err(DeError::custom)?
             .unwrap_or_default();
 
-        let kind = map
-            .remove("type")
-            .ok_or_else(|| DeError::custom("expected type"))
-            .and_then(CommandType::deserialize)
-            .map_err(DeError::custom)?;
-
-        let guild_id = match map.remove("guild_id") {
-            Some(id) => Option::<GuildId>::deserialize(id).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let target_id = match map.remove("target_id") {
-            Some(id) => Option::<TargetId>::deserialize(id).map_err(DeError::custom)?,
-            None => None,
-        };
-
         Ok(Self {
-            id,
-            name,
-            kind,
-            resolved,
             options,
-            guild_id,
-            target_id,
+            resolved,
+            id: remove_from_map(&mut map, "id")?,
+            name: remove_from_map(&mut map, "name")?,
+            kind: remove_from_map(&mut map, "type")?,
+            guild_id: remove_from_map_opt(&mut map, "guild_id")?.flatten(),
+            target_id: remove_from_map_opt(&mut map, "target_id")?.flatten(),
         })
     }
 }
@@ -608,7 +490,7 @@ pub struct CommandDataResolved {
 /// Their resolved objects can be found on [`CommandData::resolved`].
 ///
 /// [Discord docs](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-interaction-data-option-structure).
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 #[non_exhaustive]
 pub struct CommandDataOption {
     /// The name of the parameter.
@@ -629,41 +511,6 @@ pub struct CommandDataOption {
     pub resolved: Option<CommandDataOptionValue>,
 }
 
-impl<'de> Deserialize<'de> for CommandDataOption {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
-        let mut map = JsonMap::deserialize(deserializer)?;
-
-        let name = map
-            .remove("name")
-            .ok_or_else(|| DeError::custom("expected value"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
-        let value = map.remove("value");
-
-        let kind = map
-            .remove("type")
-            .ok_or_else(|| DeError::custom("expected type"))
-            .and_then(CommandOptionType::deserialize)
-            .map_err(DeError::custom)?;
-
-        let options = map
-            .remove("options")
-            .map(Vec::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?
-            .unwrap_or_default();
-
-        Ok(Self {
-            name,
-            value,
-            kind,
-            options,
-            resolved: None,
-        })
-    }
-}
-
 /// The resolved value of an [`CommandDataOption`].
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[non_exhaustive]
diff --git a/src/model/application/interaction/autocomplete.rs b/src/model/application/interaction/autocomplete.rs
index 9153e8ef2dd..30809648d45 100644
--- a/src/model/application/interaction/autocomplete.rs
+++ b/src/model/application/interaction/autocomplete.rs
@@ -11,11 +11,12 @@ use crate::http::Http;
 use crate::internal::prelude::*;
 #[cfg(feature = "http")]
 use crate::json;
+#[cfg(feature = "http")]
 use crate::json::prelude::*;
 use crate::model::application::command::{CommandOptionType, CommandType};
 #[cfg(feature = "http")]
 use crate::model::application::interaction::InteractionResponseType;
-use crate::model::application::interaction::InteractionType;
+use crate::model::application::interaction::{add_guild_id_to_resolved, InteractionType};
 use crate::model::guild::Member;
 use crate::model::id::{
     ApplicationId,
@@ -29,6 +30,7 @@ use crate::model::id::{
     UserId,
 };
 use crate::model::user::User;
+use crate::model::utils::{deserialize_val, remove_from_map, remove_from_map_opt};
 use crate::model::Permissions;
 
 /// An interaction received when the user fills in an autocomplete option
@@ -98,119 +100,31 @@ impl<'de> Deserialize<'de> for AutocompleteInteraction {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
-        let id = map.get("guild_id").and_then(Value::as_str).and_then(|x| x.parse::<u64>().ok());
-
-        if let Some(guild_id) = id {
-            if let Some(member) = map.get_mut("member").and_then(Value::as_object_mut) {
-                member.insert("guild_id".to_string(), from_number(guild_id));
-            }
+        let guild_id = remove_from_map_opt(&mut map, "guild_id")?;
 
-            if let Some(data) = map.get_mut("data") {
-                if let Some(resolved) = data.get_mut("resolved") {
-                    if let Some(roles) = resolved.get_mut("roles") {
-                        if let Some(values) = roles.as_object_mut() {
-                            for value in values.values_mut() {
-                                value.as_object_mut().expect("couldn't deserialize").insert(
-                                    "guild_id".to_string(),
-                                    Value::from(guild_id.to_string()),
-                                );
-                            }
-                        }
-                    }
-                }
-            }
+        if let Some(guild_id) = guild_id {
+            add_guild_id_to_resolved(&mut map, guild_id);
         }
 
-        let id = map
-            .remove("id")
-            .ok_or_else(|| DeError::custom("expected id"))
-            .and_then(InteractionId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let application_id = map
-            .remove("application_id")
-            .ok_or_else(|| DeError::custom("expected application id"))
-            .and_then(ApplicationId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let kind = map
-            .remove("type")
-            .ok_or_else(|| DeError::custom("expected type"))
-            .and_then(InteractionType::deserialize)
-            .map_err(DeError::custom)?;
-
-        let data = map
-            .remove("data")
-            .ok_or_else(|| DeError::custom("expected data"))
-            .and_then(AutocompleteData::deserialize)
-            .map_err(DeError::custom)?;
-
-        let guild_id = map
-            .remove("guild_id")
-            .map(GuildId::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let channel_id = map
-            .remove("channel_id")
-            .ok_or_else(|| DeError::custom("expected channel_id"))
-            .and_then(ChannelId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let member =
-            map.remove("member").map(Member::deserialize).transpose().map_err(DeError::custom)?;
-
-        let user =
-            map.remove("user").map(User::deserialize).transpose().map_err(DeError::custom)?;
-
-        let user = user
+        let member = remove_from_map_opt::<Member, _>(&mut map, "member")?;
+        let user = remove_from_map_opt(&mut map, "user")?
             .or_else(|| member.as_ref().map(|m| m.user.clone()))
             .ok_or_else(|| DeError::custom("expected user or member"))?;
 
-        let token = map
-            .remove("token")
-            .ok_or_else(|| DeError::custom("expected token"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
-        let version = map
-            .remove("version")
-            .ok_or_else(|| DeError::custom("expected version"))
-            .and_then(u8::deserialize)
-            .map_err(DeError::custom)?;
-
-        let app_permissions = map
-            .remove("app_permissions")
-            .map(Permissions::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let guild_locale = map
-            .remove("guild_locale")
-            .map(String::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let locale = map
-            .remove("locale")
-            .ok_or_else(|| DeError::custom("expected locale"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
         Ok(Self {
-            id,
-            application_id,
-            kind,
-            data,
             guild_id,
-            channel_id,
             member,
             user,
-            token,
-            version,
-            app_permissions,
-            locale,
-            guild_locale,
+            id: remove_from_map(&mut map, "id")?,
+            application_id: remove_from_map(&mut map, "application_id")?,
+            kind: remove_from_map(&mut map, "type")?,
+            data: remove_from_map(&mut map, "data")?,
+            channel_id: remove_from_map(&mut map, "channel_id")?,
+            token: remove_from_map(&mut map, "token")?,
+            version: remove_from_map(&mut map, "version")?,
+            app_permissions: remove_from_map_opt(&mut map, "app_permissions")?,
+            locale: remove_from_map(&mut map, "locale")?,
+            guild_locale: remove_from_map_opt(&mut map, "guild_locale")?,
         })
     }
 }
@@ -343,7 +257,7 @@ impl<'de> Deserialize<'de> for CommandDataOption {
                             if value.is_some() {
                                 return Err(DeError::duplicate_field("value"));
                             }
-                            value = Some(map.next_value::<serde_value::Value>()?);
+                            value = Some(map.next_value::<Value>()?);
                         },
                         Field::Options => {
                             if options.is_some() {
@@ -379,60 +293,41 @@ impl<'de> Deserialize<'de> for CommandDataOption {
                     });
                 }
 
+                let value = || value.ok_or_else(|| DeError::missing_field("value"));
+                let options = || options.ok_or_else(|| DeError::missing_field("options"));
+
                 let value = match kind {
-                    CommandOptionType::Boolean => {
-                        let value = value.ok_or_else(|| DeError::missing_field("value"))?;
-                        let value = bool::deserialize(value).map_err(DeError::custom)?;
-                        CommandDataOptionValue::Boolean(value)
+                    CommandOptionType::User => {
+                        CommandDataOptionValue::User(deserialize_val(value()?)?)
                     },
-                    CommandOptionType::Integer => {
-                        let value = value.ok_or_else(|| DeError::missing_field("value"))?;
-                        let value = i64::deserialize(value).map_err(DeError::custom)?;
-                        CommandDataOptionValue::Integer(value)
+                    CommandOptionType::Role => {
+                        CommandDataOptionValue::Role(deserialize_val(value()?)?)
                     },
                     CommandOptionType::Number => {
-                        let value = value.ok_or_else(|| DeError::missing_field("value"))?;
-                        let value = f64::deserialize(value).map_err(DeError::custom)?;
-                        CommandDataOptionValue::Number(value)
+                        CommandDataOptionValue::Number(deserialize_val(value()?)?)
                     },
                     CommandOptionType::String => {
-                        let value = value.ok_or_else(|| DeError::missing_field("value"))?;
-                        let value = String::deserialize(value).map_err(DeError::custom)?;
-                        CommandDataOptionValue::String(value)
+                        CommandDataOptionValue::String(deserialize_val(value()?)?)
                     },
-                    CommandOptionType::SubCommand => {
-                        let options = options.ok_or_else(|| DeError::missing_field("options"))?;
-                        CommandDataOptionValue::SubCommand(options)
-                    },
-                    CommandOptionType::SubCommandGroup => {
-                        let options = options.ok_or_else(|| DeError::missing_field("options"))?;
-                        CommandDataOptionValue::SubCommandGroup(options)
+                    CommandOptionType::Boolean => {
+                        CommandDataOptionValue::Boolean(deserialize_val(value()?)?)
                     },
-                    CommandOptionType::Attachment => {
-                        let value = value.ok_or_else(|| DeError::missing_field("value"))?;
-                        let value = AttachmentId::deserialize(value).map_err(DeError::custom)?;
-                        CommandDataOptionValue::Attachment(value)
+                    CommandOptionType::Integer => {
+                        CommandDataOptionValue::Integer(deserialize_val(value()?)?)
                     },
                     CommandOptionType::Channel => {
-                        let value = value.ok_or_else(|| DeError::missing_field("value"))?;
-                        let value = ChannelId::deserialize(value).map_err(DeError::custom)?;
-                        CommandDataOptionValue::Channel(value)
+                        CommandDataOptionValue::Channel(deserialize_val(value()?)?)
                     },
-                    CommandOptionType::Mentionable => {
-                        let value = value.ok_or_else(|| DeError::missing_field("value"))?;
-                        let value = GenericId::deserialize(value).map_err(DeError::custom)?;
-                        CommandDataOptionValue::Mentionable(value)
+                    CommandOptionType::Attachment => {
+                        CommandDataOptionValue::Attachment(deserialize_val(value()?)?)
                     },
-                    CommandOptionType::Role => {
-                        let value = value.ok_or_else(|| DeError::missing_field("value"))?;
-                        let value = RoleId::deserialize(value).map_err(DeError::custom)?;
-                        CommandDataOptionValue::Role(value)
+                    CommandOptionType::Mentionable => {
+                        CommandDataOptionValue::Mentionable(deserialize_val(value()?)?)
                     },
-                    CommandOptionType::User => {
-                        let value = value.ok_or_else(|| DeError::missing_field("value"))?;
-                        let value = UserId::deserialize(value).map_err(DeError::custom)?;
-                        CommandDataOptionValue::User(value)
+                    CommandOptionType::SubCommandGroup => {
+                        CommandDataOptionValue::SubCommandGroup(options()?)
                     },
+                    CommandOptionType::SubCommand => CommandDataOptionValue::SubCommand(options()?),
                     CommandOptionType::Unknown => CommandDataOptionValue::Unknown,
                 };
 
@@ -481,10 +376,10 @@ impl Serialize for CommandDataOption {
             CommandDataOptionValue::Mentionable(v) => s.serialize_field("value", v)?,
             CommandDataOptionValue::Role(v) => s.serialize_field("value", v)?,
             CommandDataOptionValue::User(v) => s.serialize_field("value", v)?,
-            CommandDataOptionValue::SubCommand(o) | CommandDataOptionValue::SubCommandGroup(o) => {
-                if !o.is_empty() {
-                    s.serialize_field("options", o)?;
-                }
+            CommandDataOptionValue::SubCommand(o) | CommandDataOptionValue::SubCommandGroup(o)
+                if !o.is_empty() =>
+            {
+                s.serialize_field("options", o)?;
             },
             _ => {},
         }
diff --git a/src/model/application/interaction/message_component.rs b/src/model/application/interaction/message_component.rs
index b9daaf90668..bf626c3361c 100644
--- a/src/model/application/interaction/message_component.rs
+++ b/src/model/application/interaction/message_component.rs
@@ -12,17 +12,17 @@ use crate::http::Http;
 use crate::internal::prelude::*;
 #[cfg(feature = "http")]
 use crate::json;
-use crate::json::prelude::*;
 use crate::model::application::component::ComponentType;
 #[cfg(feature = "http")]
 use crate::model::application::interaction::InteractionResponseType;
-use crate::model::application::interaction::InteractionType;
+use crate::model::application::interaction::{add_guild_id_to_resolved, InteractionType};
 use crate::model::channel::Message;
 use crate::model::guild::Member;
 #[cfg(feature = "http")]
 use crate::model::id::MessageId;
 use crate::model::id::{ApplicationId, ChannelId, GuildId, InteractionId};
 use crate::model::user::User;
+use crate::model::utils::{remove_from_map, remove_from_map_opt};
 use crate::model::Permissions;
 
 /// An interaction triggered by a message component.
@@ -341,129 +341,32 @@ impl<'de> Deserialize<'de> for MessageComponentInteraction {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
-        let id = map.get("guild_id").and_then(Value::as_str).and_then(|x| x.parse::<u64>().ok());
-
-        if let Some(guild_id) = id {
-            if let Some(member) = map.get_mut("member").and_then(Value::as_object_mut) {
-                member.insert("guild_id".to_string(), from_number(guild_id));
-            }
-
-            if let Some(data) = map.get_mut("data") {
-                if let Some(resolved) = data.get_mut("resolved") {
-                    if let Some(roles) = resolved.get_mut("roles") {
-                        if let Some(values) = roles.as_object_mut() {
-                            for value in values.values_mut() {
-                                value
-                                    .as_object_mut()
-                                    .expect("couldn't deserialize message component")
-                                    .insert(
-                                        "guild_id".to_string(),
-                                        Value::from(guild_id.to_string()),
-                                    );
-                            }
-                        }
-                    }
-                }
-            }
+        let guild_id = remove_from_map_opt(&mut map, "guild_id")?;
+
+        if let Some(guild_id) = guild_id {
+            add_guild_id_to_resolved(&mut map, guild_id);
         }
 
-        let id = map
-            .remove("id")
-            .ok_or_else(|| DeError::custom("expected id"))
-            .and_then(InteractionId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let application_id = map
-            .remove("application_id")
-            .ok_or_else(|| DeError::custom("expected application id"))
-            .and_then(ApplicationId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let kind = map
-            .remove("type")
-            .ok_or_else(|| DeError::custom("expected type"))
-            .and_then(InteractionType::deserialize)
-            .map_err(DeError::custom)?;
-
-        let data = map
-            .remove("data")
-            .ok_or_else(|| DeError::custom("expected data"))
-            .and_then(MessageComponentInteractionData::deserialize)
-            .map_err(DeError::custom)?;
-
-        let guild_id = map
-            .remove("guild_id")
-            .map(GuildId::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let channel_id = map
-            .remove("channel_id")
-            .ok_or_else(|| DeError::custom("expected channel_id"))
-            .and_then(ChannelId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let member =
-            map.remove("member").map(Member::deserialize).transpose().map_err(DeError::custom)?;
-
-        let user =
-            map.remove("user").map(User::deserialize).transpose().map_err(DeError::custom)?;
-
-        let user = user
+        let member = remove_from_map_opt::<Member, _>(&mut map, "member")?;
+        let user = remove_from_map_opt(&mut map, "user")?
             .or_else(|| member.as_ref().map(|m| m.user.clone()))
             .ok_or_else(|| DeError::custom("expected user or member"))?;
 
-        let message = map
-            .remove("message")
-            .ok_or_else(|| DeError::custom("expected message"))
-            .and_then(Message::deserialize)
-            .map_err(DeError::custom)?;
-
-        let token = map
-            .remove("token")
-            .ok_or_else(|| DeError::custom("expected token"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
-        let version = map
-            .remove("version")
-            .ok_or_else(|| DeError::custom("expected version"))
-            .and_then(u8::deserialize)
-            .map_err(DeError::custom)?;
-
-        let app_permissions = map
-            .remove("app_permissions")
-            .map(Permissions::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let guild_locale = map
-            .remove("guild_locale")
-            .map(String::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let locale = map
-            .remove("locale")
-            .ok_or_else(|| DeError::custom("expected locale"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
         Ok(Self {
-            id,
-            application_id,
-            kind,
-            data,
             guild_id,
-            channel_id,
             member,
             user,
-            token,
-            version,
-            message,
-            app_permissions,
-            locale,
-            guild_locale,
+            id: remove_from_map(&mut map, "id")?,
+            application_id: remove_from_map(&mut map, "application_id")?,
+            kind: remove_from_map(&mut map, "type")?,
+            data: remove_from_map(&mut map, "data")?,
+            channel_id: remove_from_map(&mut map, "channel_id")?,
+            token: remove_from_map(&mut map, "token")?,
+            version: remove_from_map(&mut map, "version")?,
+            message: remove_from_map(&mut map, "message")?,
+            app_permissions: remove_from_map_opt(&mut map, "app_permissions")?,
+            locale: remove_from_map(&mut map, "locale")?,
+            guild_locale: remove_from_map_opt(&mut map, "guild_locale")?,
         })
     }
 }
diff --git a/src/model/application/interaction/mod.rs b/src/model/application/interaction/mod.rs
index 7c4d64df53a..fcdefa04df5 100644
--- a/src/model/application/interaction/mod.rs
+++ b/src/model/application/interaction/mod.rs
@@ -12,9 +12,11 @@ use self::autocomplete::AutocompleteInteraction;
 use self::message_component::MessageComponentInteraction;
 use self::modal::ModalSubmitInteraction;
 use self::ping::PingInteraction;
-use crate::json::{from_value, JsonMap, Value};
-use crate::model::id::{ApplicationId, InteractionId};
+use crate::internal::prelude::*;
+use crate::json::{from_number, from_value};
+use crate::model::id::{ApplicationId, GuildId, InteractionId};
 use crate::model::user::User;
+use crate::model::utils::deserialize_val;
 use crate::model::Permissions;
 
 /// [Discord docs](https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-object)
@@ -222,50 +224,35 @@ impl Interaction {
 }
 
 impl<'de> Deserialize<'de> for Interaction {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let map = JsonMap::deserialize(deserializer)?;
-
-        let kind = map
-            .get("type")
-            .ok_or_else(|| DeError::custom("expected type"))
-            .and_then(InteractionType::deserialize)
-            .map_err(DeError::custom)?;
-
-        match kind {
-            InteractionType::Ping => from_value::<PingInteraction>(Value::from(map))
-                .map(Interaction::Ping)
-                .map_err(DeError::custom),
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> std::result::Result<Self, D::Error> {
+        let value = Value::deserialize(deserializer)?;
+        let map = value.as_object().ok_or_else(|| DeError::custom("expected JsonMap"))?;
+
+        let raw_kind = map.get("type").ok_or_else(|| DeError::missing_field("type"))?;
+        match deserialize_val(raw_kind.clone())? {
             InteractionType::ApplicationCommand => {
-                from_value::<ApplicationCommandInteraction>(Value::from(map))
-                    .map(Interaction::ApplicationCommand)
-                    .map_err(DeError::custom)
+                from_value(value).map(Interaction::ApplicationCommand)
             },
             InteractionType::MessageComponent => {
-                from_value::<MessageComponentInteraction>(Value::from(map))
-                    .map(Interaction::MessageComponent)
-                    .map_err(DeError::custom)
-            },
-            InteractionType::Autocomplete => {
-                from_value::<AutocompleteInteraction>(Value::from(map))
-                    .map(Interaction::Autocomplete)
-                    .map_err(DeError::custom)
+                from_value(value).map(Interaction::MessageComponent)
             },
-            InteractionType::ModalSubmit => from_value::<ModalSubmitInteraction>(Value::from(map))
-                .map(Interaction::ModalSubmit)
-                .map_err(DeError::custom),
-            InteractionType::Unknown => Err(DeError::custom("Unknown interaction type")),
+            InteractionType::Autocomplete => from_value(value).map(Interaction::Autocomplete),
+            InteractionType::ModalSubmit => from_value(value).map(Interaction::ModalSubmit),
+            InteractionType::Ping => from_value(value).map(Interaction::Ping),
+            InteractionType::Unknown => return Err(DeError::custom("Unknown interaction type")),
         }
+        .map_err(DeError::custom)
     }
 }
 
 impl Serialize for Interaction {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
         match self {
-            Self::Ping(i) => PingInteraction::serialize(i, serializer),
-            Self::ApplicationCommand(i) => ApplicationCommandInteraction::serialize(i, serializer),
-            Self::MessageComponent(i) => MessageComponentInteraction::serialize(i, serializer),
-            Self::Autocomplete(i) => AutocompleteInteraction::serialize(i, serializer),
-            Self::ModalSubmit(i) => ModalSubmitInteraction::serialize(i, serializer),
+            Self::Ping(i) => i.serialize(serializer),
+            Self::ApplicationCommand(i) => i.serialize(serializer),
+            Self::MessageComponent(i) => i.serialize(serializer),
+            Self::Autocomplete(i) => i.serialize(serializer),
+            Self::ModalSubmit(i) => i.serialize(serializer),
         }
     }
 }
@@ -343,3 +330,23 @@ pub enum InteractionResponseType {
     Autocomplete = 8,
     Modal = 9,
 }
+
+fn add_guild_id_to_resolved(map: &mut JsonMap, guild_id: GuildId) {
+    if let Some(member) = map.get_mut("member").and_then(Value::as_object_mut) {
+        member.insert("guild_id".to_string(), from_number(guild_id.0));
+    }
+
+    if let Some(data) = map.get_mut("data") {
+        if let Some(resolved) = data.get_mut("resolved") {
+            if let Some(roles) = resolved.get_mut("roles") {
+                if let Some(values) = roles.as_object_mut() {
+                    for value in values.values_mut() {
+                        if let Some(role) = value.as_object_mut() {
+                            role.insert("guild_id".to_string(), from_number(guild_id.0));
+                        };
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/model/application/interaction/modal.rs b/src/model/application/interaction/modal.rs
index 493c574d1b8..ec9172ddef7 100644
--- a/src/model/application/interaction/modal.rs
+++ b/src/model/application/interaction/modal.rs
@@ -12,7 +12,6 @@ use crate::http::Http;
 use crate::internal::prelude::*;
 #[cfg(feature = "model")]
 use crate::json;
-use crate::json::prelude::*;
 use crate::model::application::component::ActionRow;
 #[cfg(feature = "http")]
 use crate::model::application::interaction::InteractionResponseType;
@@ -23,6 +22,7 @@ use crate::model::guild::Member;
 use crate::model::id::MessageId;
 use crate::model::id::{ApplicationId, ChannelId, GuildId, InteractionId};
 use crate::model::user::User;
+use crate::model::utils::{remove_from_map, remove_from_map_opt};
 use crate::model::Permissions;
 
 /// An interaction triggered by a modal submit.
@@ -306,126 +306,26 @@ impl<'de> Deserialize<'de> for ModalSubmitInteraction {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
-        let id = map.get("guild_id").and_then(Value::as_str).and_then(|x| x.parse::<u64>().ok());
-
-        if let Some(guild_id) = id {
-            if let Some(member) = map.get_mut("member").and_then(Value::as_object_mut) {
-                member.insert("guild_id".to_string(), from_number(guild_id));
-            }
-
-            if let Some(data) = map.get_mut("data") {
-                if let Some(resolved) = data.get_mut("resolved") {
-                    if let Some(roles) = resolved.get_mut("roles") {
-                        if let Some(values) = roles.as_object_mut() {
-                            for value in values.values_mut() {
-                                value
-                                    .as_object_mut()
-                                    .expect("couldn't deserialize message component")
-                                    .insert(
-                                        "guild_id".to_string(),
-                                        Value::String(guild_id.to_string()),
-                                    );
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        let id = map
-            .remove("id")
-            .ok_or_else(|| DeError::custom("expected id"))
-            .and_then(InteractionId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let application_id = map
-            .remove("application_id")
-            .ok_or_else(|| DeError::custom("expected application id"))
-            .and_then(ApplicationId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let kind = map
-            .remove("type")
-            .ok_or_else(|| DeError::custom("expected type"))
-            .and_then(InteractionType::deserialize)
-            .map_err(DeError::custom)?;
-
-        let data = map
-            .remove("data")
-            .ok_or_else(|| DeError::custom("expected data"))
-            .and_then(ModalSubmitInteractionData::deserialize)
-            .map_err(DeError::custom)?;
-
-        let guild_id = map
-            .remove("guild_id")
-            .map(GuildId::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let channel_id = map
-            .remove("channel_id")
-            .ok_or_else(|| DeError::custom("expected channel_id"))
-            .and_then(ChannelId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let member =
-            map.remove("member").map(Member::deserialize).transpose().map_err(DeError::custom)?;
-
-        let user =
-            map.remove("user").map(User::deserialize).transpose().map_err(DeError::custom)?;
-
-        let user = user
+        let member = remove_from_map_opt::<Member, _>(&mut map, "member")?;
+        let user = remove_from_map_opt(&mut map, "user")?
             .or_else(|| member.as_ref().map(|m| m.user.clone()))
             .ok_or_else(|| DeError::custom("expected user or member"))?;
 
-        let message =
-            map.remove("message").map(Message::deserialize).transpose().map_err(DeError::custom)?;
-
-        let token = map
-            .remove("token")
-            .ok_or_else(|| DeError::custom("expected token"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
-        let version = map
-            .remove("version")
-            .ok_or_else(|| DeError::custom("expected version"))
-            .and_then(u8::deserialize)
-            .map_err(DeError::custom)?;
-
-        let app_permissions = map
-            .remove("app_permissions")
-            .map(Permissions::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let guild_locale = map
-            .remove("guild_locale")
-            .map(String::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let locale = map
-            .remove("locale")
-            .ok_or_else(|| DeError::custom("expected locale"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
         Ok(Self {
-            id,
-            application_id,
-            kind,
-            data,
-            guild_id,
-            channel_id,
             member,
             user,
-            token,
-            version,
-            message,
-            app_permissions,
-            locale,
-            guild_locale,
+            id: remove_from_map(&mut map, "id")?,
+            guild_id: remove_from_map_opt(&mut map, "guild_id")?,
+            application_id: remove_from_map(&mut map, "application_id")?,
+            kind: remove_from_map(&mut map, "type")?,
+            data: remove_from_map(&mut map, "data")?,
+            channel_id: remove_from_map(&mut map, "channel_id")?,
+            token: remove_from_map(&mut map, "token")?,
+            version: remove_from_map(&mut map, "version")?,
+            message: remove_from_map(&mut map, "message")?,
+            app_permissions: remove_from_map_opt(&mut map, "app_permissions")?,
+            locale: remove_from_map(&mut map, "locale")?,
+            guild_locale: remove_from_map_opt(&mut map, "guild_locale")?,
         })
     }
 }
diff --git a/src/model/channel/mod.rs b/src/model/channel/mod.rs
index 26818f96070..569df5e5f19 100644
--- a/src/model/channel/mod.rs
+++ b/src/model/channel/mod.rs
@@ -224,33 +224,26 @@ impl Channel {
 
 impl<'de> Deserialize<'de> for Channel {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
-        let v = JsonMap::deserialize(deserializer)?;
+        let value = Value::deserialize(deserializer)?;
+        let map = value.as_object().ok_or_else(|| DeError::custom("expected a JsonMap"))?;
+
         let kind = {
-            let kind = v.get("type").ok_or_else(|| DeError::missing_field("type"))?;
-
-            match kind.as_u64() {
-                Some(kind) => kind,
-                None => {
-                    return Err(DeError::invalid_type(
-                        Unexpected::Other("non-positive integer"),
-                        &"a positive integer",
-                    ));
-                },
-            }
+            let kind = map.get("type").ok_or_else(|| DeError::missing_field("type"))?;
+            kind.as_u64().ok_or_else(|| {
+                DeError::invalid_type(
+                    Unexpected::Other("non-positive integer"),
+                    &"a positive integer",
+                )
+            })?
         };
 
         match kind {
-            0 | 2 | 5 | 10 | 11 | 12 | 13 | 14 | 15 => from_value::<GuildChannel>(Value::from(v))
-                .map(Channel::Guild)
-                .map_err(DeError::custom),
-            1 => from_value::<PrivateChannel>(Value::from(v))
-                .map(Channel::Private)
-                .map_err(DeError::custom),
-            4 => from_value::<ChannelCategory>(Value::from(v))
-                .map(Channel::Category)
-                .map_err(DeError::custom),
-            _ => Err(DeError::custom("Unknown channel type")),
+            0 | 2 | 5 | 10 | 11 | 12 | 13 | 14 | 15 => from_value(value).map(Channel::Guild),
+            1 => from_value(value).map(Channel::Private),
+            4 => from_value(value).map(Channel::Category),
+            _ => return Err(DeError::custom("Unknown channel type")),
         }
+        .map_err(DeError::custom)
     }
 }
 
diff --git a/src/model/channel/reaction.rs b/src/model/channel/reaction.rs
index 7f2917931f6..eed19bb9af9 100644
--- a/src/model/channel/reaction.rs
+++ b/src/model/channel/reaction.rs
@@ -16,7 +16,9 @@ use tracing::warn;
 #[cfg(feature = "model")]
 use crate::http::{CacheHttp, Http};
 use crate::internal::prelude::*;
+use crate::json::from_number;
 use crate::model::prelude::*;
+use crate::model::utils::{remove_from_map, remove_from_map_opt};
 
 /// An emoji reaction to a message.
 ///
@@ -44,54 +46,23 @@ impl<'de> Deserialize<'de> for Reaction {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
-        let channel_id = map
-            .remove("channel_id")
-            .ok_or_else(|| DeError::custom("expected channel_id"))
-            .and_then(ChannelId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let message_id = map
-            .remove("message_id")
-            .ok_or_else(|| DeError::custom("expected message_id"))
-            .and_then(MessageId::deserialize)
-            .map_err(DeError::custom)?;
-
-        let emoji = map
-            .remove("emoji")
-            .ok_or_else(|| DeError::custom("expected emoji"))
-            .and_then(ReactionType::deserialize)
-            .map_err(DeError::custom)?;
-
-        let user_id =
-            map.remove("user_id").map(UserId::deserialize).transpose().map_err(DeError::custom)?;
-
-        let guild_id = map
-            .remove("guild_id")
-            .map(GuildId::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
+        let guild_id = remove_from_map_opt::<GuildId, _>(&mut map, "guild_id")?;
 
         if let Some(id) = guild_id {
             if let Some(member) = map.get_mut("member") {
                 if let Some(object) = member.as_object_mut() {
-                    object.insert("guild_id".to_owned(), Value::from(id.to_string()));
+                    object.insert("guild_id".to_owned(), from_number(id.0));
                 }
             }
         }
 
-        let member = map
-            .remove("member")
-            .map(PartialMember::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
         Ok(Self {
-            channel_id,
-            emoji,
-            message_id,
-            user_id,
             guild_id,
-            member,
+            channel_id: remove_from_map(&mut map, "channel_id")?,
+            message_id: remove_from_map(&mut map, "message_id")?,
+            user_id: remove_from_map_opt(&mut map, "user_id")?,
+            member: remove_from_map_opt(&mut map, "member")?,
+            emoji: remove_from_map(&mut map, "emoji")?,
         })
     }
 }
diff --git a/src/model/event.rs b/src/model/event.rs
index eb93c45d05f..1161ee1865b 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -9,6 +9,7 @@ use serde::de::{Error as DeError, IgnoredAny, MapAccess};
 use super::application::component::ActionRow;
 use super::prelude::*;
 use super::utils::{
+    add_guild_id_to_map,
     deserialize_val,
     emojis,
     ignore_input,
@@ -121,7 +122,7 @@ pub struct GuildBanRemoveEvent {
 }
 
 /// [Discord docs](https://discord.com/developers/docs/topics/gateway#guild-create).
-#[derive(Clone, Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Serialize)]
 #[serde(transparent)]
 #[non_exhaustive]
 pub struct GuildCreateEvent {
@@ -129,6 +130,24 @@ pub struct GuildCreateEvent {
 }
 
 /// [Discord docs](https://discord.com/developers/docs/topics/gateway#guild-delete).
+impl<'de> Deserialize<'de> for GuildCreateEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
+        let mut value = Value::deserialize(deserializer)?;
+        let map = value.as_object_mut().ok_or_else(|| DeError::custom("expected JsonMap"))?;
+
+        let id_val = map.get("id").ok_or_else(|| DeError::missing_field("id"))?;
+        let id = deserialize_val(id_val.clone())?;
+
+        add_guild_id_to_map(map, "channels", id);
+        add_guild_id_to_map(map, "members", id);
+        add_guild_id_to_map(map, "roles", id);
+
+        deserialize_val(value).map(|guild| Self {
+            guild,
+        })
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(transparent)]
 #[non_exhaustive]
diff --git a/src/model/guild/mod.rs b/src/model/guild/mod.rs
index c3d56fc2c3b..66645967b2e 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -17,7 +17,6 @@ mod welcome_screen;
 #[cfg(feature = "model")]
 use std::borrow::Cow;
 
-use serde::de::Error as DeError;
 #[cfg(feature = "model")]
 use tracing::error;
 #[cfg(all(feature = "model", feature = "cache"))]
@@ -68,8 +67,8 @@ use crate::collector::{
 use crate::constants::LARGE_THRESHOLD;
 #[cfg(feature = "model")]
 use crate::http::{CacheHttp, Http, UserPagination};
-use crate::json::prelude::*;
-use crate::json::{from_number, from_value};
+#[cfg(feature = "model")]
+use crate::json::prelude::json;
 #[cfg(feature = "model")]
 use crate::model::application::command::{Command, CommandPermission};
 #[cfg(feature = "model")]
@@ -93,7 +92,7 @@ pub struct Ban {
 ///
 /// [Discord docs](https://discord.com/developers/docs/resources/guild#guild-object) plus
 /// [extension](https://discord.com/developers/docs/topics/gateway#guild-create).
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 #[non_exhaustive]
 pub struct Guild {
     /// Id of a voice channel that's considered the AFK channel.
@@ -108,12 +107,13 @@ pub struct Guild {
     /// This contains all channels regardless of permissions (i.e. the ability
     /// of the bot to read from or connect to them).
     #[serde(serialize_with = "serialize_map_values")]
+    #[serde(deserialize_with = "deserialize_guild_channels")]
     pub channels: HashMap<ChannelId, Channel>,
     /// Indicator of whether notifications for all messages are enabled by
     /// default in the guild.
     pub default_message_notifications: DefaultMessageNotificationLevel,
     /// All of the guild's custom emojis.
-    #[serde(serialize_with = "serialize_map_values")]
+    #[serde(with = "emojis")]
     pub emojis: HashMap<EmojiId, Emoji>,
     /// Default explicit content filter level.
     pub explicit_content_filter: ExplicitContentFilter,
@@ -171,6 +171,7 @@ pub struct Guild {
     /// if the [`Self::member_count`] is greater than the [`LARGE_THRESHOLD`] set by
     /// the library.
     #[serde(serialize_with = "serialize_map_values")]
+    #[serde(deserialize_with = "deserialize_members")]
     pub members: HashMap<UserId, Member>,
     /// Indicator of whether the guild requires multi-factor authentication for
     /// [`Role`]s or [`User`]s with moderation permissions.
@@ -183,10 +184,10 @@ pub struct Guild {
     ///
     /// **Note**: This will be empty unless the "guild presences" privileged
     /// intent is enabled.
-    #[serde(serialize_with = "serialize_map_values")]
+    #[serde(with = "presences")]
     pub presences: HashMap<UserId, Presence>,
     /// A mapping of the guild's roles.
-    #[serde(serialize_with = "serialize_map_values")]
+    #[serde(with = "roles")]
     pub roles: HashMap<RoleId, Role>,
     /// An identifying hash of the guild's splash icon.
     ///
@@ -214,6 +215,7 @@ pub struct Guild {
     pub verification_level: VerificationLevel,
     /// A mapping of [`User`]s to their current voice state.
     #[serde(serialize_with = "serialize_map_values")]
+    #[serde(deserialize_with = "deserialize_voice_states")]
     pub voice_states: HashMap<UserId, VoiceState>,
     /// The server's description, if it has one.
     pub description: Option<String>,
@@ -261,7 +263,7 @@ pub struct Guild {
     #[serde(default)]
     pub threads: Vec<GuildChannel>,
     /// All of the guild's custom stickers.
-    #[serde(serialize_with = "serialize_map_values")]
+    #[serde(with = "stickers")]
     pub stickers: HashMap<StickerId, Sticker>,
 }
 
@@ -2698,313 +2700,6 @@ impl Guild {
     }
 }
 
-impl<'de> Deserialize<'de> for Guild {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
-        let mut map = JsonMap::deserialize(deserializer)?;
-
-        let id = map.get("id").and_then(Value::as_str).and_then(|x| x.parse::<u64>().ok());
-
-        if let Some(guild_id) = id {
-            if let Some(array) = map.get_mut("channels").and_then(Value::as_array_mut) {
-                for value in array {
-                    if let Some(channel) = value.as_object_mut() {
-                        channel.insert("guild_id".to_string(), from_number(guild_id));
-                    }
-                }
-            }
-
-            if let Some(array) = map.get_mut("members").and_then(Value::as_array_mut) {
-                for value in array {
-                    if let Some(member) = value.as_object_mut() {
-                        member.insert("guild_id".to_string(), from_number(guild_id));
-                    }
-                }
-            }
-
-            if let Some(array) = map.get_mut("roles").and_then(Value::as_array_mut) {
-                for value in array {
-                    if let Some(role) = value.as_object_mut() {
-                        role.insert("guild_id".to_string(), from_number(guild_id));
-                    }
-                }
-            }
-        }
-
-        let afk_channel_id = match map.remove("afk_channel_id") {
-            Some(v) => from_value::<Option<ChannelId>>(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let afk_timeout = map
-            .remove("afk_timeout")
-            .ok_or_else(|| DeError::custom("expected guild afk_timeout"))
-            .and_then(u64::deserialize)
-            .map_err(DeError::custom)?;
-        let application_id = match map.remove("application_id") {
-            Some(v) => from_value::<Option<ApplicationId>>(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let channels = map
-            .remove("channels")
-            .ok_or_else(|| DeError::custom("expected guild channels"))
-            .and_then(deserialize_guild_channels)
-            .map_err(DeError::custom)?;
-        let default_message_notifications = map
-            .remove("default_message_notifications")
-            .ok_or_else(|| DeError::custom("expected guild default_message_notifications"))
-            .and_then(DefaultMessageNotificationLevel::deserialize)
-            .map_err(DeError::custom)?;
-        let emojis = map
-            .remove("emojis")
-            .ok_or_else(|| DeError::custom("expected guild emojis"))
-            .and_then(emojis::deserialize)
-            .map_err(DeError::custom)?;
-        let explicit_content_filter = map
-            .remove("explicit_content_filter")
-            .ok_or_else(|| DeError::custom("expected guild explicit_content_filter"))
-            .and_then(ExplicitContentFilter::deserialize)
-            .map_err(DeError::custom)?;
-        let features = map
-            .remove("features")
-            .ok_or(Error::Other("expected guild features"))
-            .and_then(from_value::<Vec<String>>)
-            .map_err(DeError::custom)?;
-        let icon = match map.remove("icon") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let id = map
-            .remove("id")
-            .ok_or_else(|| DeError::custom("expected guild id"))
-            .and_then(GuildId::deserialize)
-            .map_err(DeError::custom)?;
-        let joined_at = map
-            .remove("joined_at")
-            .ok_or_else(|| DeError::custom("expected guild joined_at"))
-            .and_then(Timestamp::deserialize)
-            .map_err(DeError::custom)?;
-        let large = map
-            .remove("large")
-            .ok_or_else(|| DeError::custom("expected guild large"))
-            .and_then(bool::deserialize)
-            .map_err(DeError::custom)?;
-        let member_count = map
-            .remove("member_count")
-            .ok_or_else(|| DeError::custom("expected guild member_count"))
-            .and_then(u64::deserialize)
-            .map_err(DeError::custom)?;
-        let members = map
-            .remove("members")
-            .ok_or_else(|| DeError::custom("expected guild members"))
-            .and_then(deserialize_members)
-            .map_err(DeError::custom)?;
-        let mfa_level = map
-            .remove("mfa_level")
-            .ok_or_else(|| DeError::custom("expected guild mfa_level"))
-            .and_then(MfaLevel::deserialize)
-            .map_err(DeError::custom)?;
-        let name = map
-            .remove("name")
-            .ok_or_else(|| DeError::custom("expected guild name"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-        let owner_id = map
-            .remove("owner_id")
-            .ok_or_else(|| DeError::custom("expected guild owner_id"))
-            .and_then(UserId::deserialize)
-            .map_err(DeError::custom)?;
-        let presences = map
-            .remove("presences")
-            .ok_or_else(|| DeError::custom("expected guild presences"))
-            .and_then(presences::deserialize)
-            .map_err(DeError::custom)?;
-        let roles = map
-            .remove("roles")
-            .ok_or_else(|| DeError::custom("expected guild roles"))
-            .and_then(roles::deserialize)
-            .map_err(DeError::custom)?;
-        let splash = match map.remove("splash") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let system_channel_id = match map.remove("system_channel_id") {
-            Some(v) => Option::<ChannelId>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let verification_level = map
-            .remove("verification_level")
-            .ok_or_else(|| DeError::custom("expected guild verification_level"))
-            .and_then(VerificationLevel::deserialize)
-            .map_err(DeError::custom)?;
-        let voice_states = map
-            .remove("voice_states")
-            .ok_or_else(|| DeError::custom("expected guild voice_states"))
-            .and_then(deserialize_voice_states)
-            .map_err(DeError::custom)?;
-        let description = match map.remove("description") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let premium_tier = match map.remove("premium_tier") {
-            Some(v) => PremiumTier::deserialize(v).map_err(DeError::custom)?,
-            None => PremiumTier::default(),
-        };
-        let premium_subscription_count = match map.remove("premium_subscription_count") {
-            #[cfg(not(feature = "simd_json"))]
-            Some(Value::Null) | None => 0,
-            #[cfg(feature = "simd_json")]
-            Some(Value::Static(StaticNode::Null)) | None => 0,
-            Some(v) => u64::deserialize(v).map_err(DeError::custom)?,
-        };
-        let banner = match map.remove("banner") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let vanity_url_code = match map.remove("vanity_url_code") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let preferred_locale = map
-            .remove("preferred_locale")
-            .ok_or_else(|| DeError::custom("expected preferred locale"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-
-        let welcome_screen = map
-            .remove("welcome_screen")
-            .map(GuildWelcomeScreen::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let approximate_member_count = map
-            .remove("approximate_member_count")
-            .map(u64::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let approximate_presence_count = map
-            .remove("approximate_presence_count")
-            .map(u64::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let max_video_channel_users = map
-            .remove("max_video_channel_users")
-            .map(u64::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let max_presences = match map.remove("max_presences") {
-            Some(v) => Option::<u64>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let max_members =
-            map.remove("max_members").map(u64::deserialize).transpose().map_err(DeError::custom)?;
-
-        let discovery_splash = match map.remove("discovery_splash") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let nsfw_level = map
-            .remove("nsfw_level")
-            .ok_or_else(|| DeError::custom("expected nsfw_level"))
-            .and_then(NsfwLevel::deserialize)
-            .map_err(DeError::custom)?;
-
-        let widget_enabled = match map.remove("widget_enabled") {
-            Some(v) => Option::<bool>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let widget_channel_id = match map.remove("widget_channel_id") {
-            Some(v) => Option::<ChannelId>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let rules_channel_id = match map.remove("rules_channel_id") {
-            Some(v) => Option::<ChannelId>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let public_updates_channel_id = match map.remove("public_updates_channel_id") {
-            Some(v) => Option::<ChannelId>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let system_channel_flags = map
-            .remove("system_channel_flags")
-            .ok_or_else(|| DeError::custom("expected system_channel_flags"))
-            .and_then(SystemChannelFlags::deserialize)
-            .map_err(DeError::custom)?;
-
-        let stage_instances = match map.remove("stage_instances") {
-            Some(v) => Vec::<StageInstance>::deserialize(v).map_err(DeError::custom)?,
-            None => Vec::new(),
-        };
-
-        let threads = match map.remove("threads") {
-            Some(v) => Vec::<GuildChannel>::deserialize(v).map_err(DeError::custom)?,
-            None => Vec::new(),
-        };
-
-        let stickers = map
-            .remove("stickers")
-            .ok_or_else(|| DeError::custom("expected guild stickers"))
-            .and_then(stickers::deserialize)
-            .map_err(DeError::custom)?;
-
-        Ok(Self {
-            afk_channel_id,
-            afk_timeout,
-            application_id,
-            channels,
-            default_message_notifications,
-            emojis,
-            explicit_content_filter,
-            features,
-            icon,
-            id,
-            joined_at,
-            large,
-            member_count,
-            members,
-            mfa_level,
-            name,
-            owner_id,
-            presences,
-            roles,
-            splash,
-            discovery_splash,
-            system_channel_id,
-            system_channel_flags,
-            rules_channel_id,
-            public_updates_channel_id,
-            verification_level,
-            voice_states,
-            description,
-            premium_tier,
-            premium_subscription_count,
-            banner,
-            vanity_url_code,
-            preferred_locale,
-            welcome_screen,
-            approximate_member_count,
-            approximate_presence_count,
-            nsfw_level,
-            max_video_channel_users,
-            max_presences,
-            max_members,
-            widget_enabled,
-            widget_channel_id,
-            stage_instances,
-            threads,
-            stickers,
-        })
-    }
-}
-
 /// Checks if a `&str` contains another `&str`.
 #[cfg(feature = "model")]
 fn contains_case_insensitive(to_look_at: &str, to_find: &str) -> bool {
diff --git a/src/model/guild/partial_guild.rs b/src/model/guild/partial_guild.rs
index c3672165c61..032a4b800b3 100644
--- a/src/model/guild/partial_guild.rs
+++ b/src/model/guild/partial_guild.rs
@@ -31,13 +31,19 @@ use crate::collector::{
 #[cfg(feature = "model")]
 use crate::http::{CacheHttp, Http};
 use crate::json::prelude::*;
-use crate::json::{from_number, from_value};
 #[cfg(feature = "model")]
 use crate::model::application::command::{Command, CommandPermission};
 #[cfg(feature = "model")]
 use crate::model::guild::automod::Rule;
 use crate::model::prelude::*;
-use crate::model::utils::{emojis, roles, stickers};
+use crate::model::utils::{
+    add_guild_id_to_map,
+    emojis,
+    remove_from_map,
+    remove_from_map_opt,
+    roles,
+    stickers,
+};
 
 /// Partial information about a [`Guild`]. This does not include information
 /// like member data.
@@ -1652,88 +1658,22 @@ impl<'de> Deserialize<'de> for PartialGuild {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
-        let id = map.get("id").and_then(Value::as_str).and_then(|x| x.parse::<u64>().ok());
+        let id = remove_from_map(&mut map, "id")?;
 
-        if let Some(guild_id) = id {
-            if let Some(array) = map.get_mut("roles").and_then(Value::as_array_mut) {
-                for value in array {
-                    if let Some(role) = value.as_object_mut() {
-                        role.insert("guild_id".to_string(), from_number(guild_id));
-                    }
-                }
-            }
-        }
+        add_guild_id_to_map(&mut map, "roles", id);
 
-        let afk_channel_id = match map.remove("afk_channel_id") {
-            Some(v) => from_value::<Option<ChannelId>>(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let afk_timeout = map
-            .remove("afk_timeout")
-            .ok_or_else(|| DeError::custom("expected guild afk_timeout"))
-            .and_then(u64::deserialize)
-            .map_err(DeError::custom)?;
-        let default_message_notifications = map
-            .remove("default_message_notifications")
-            .ok_or_else(|| DeError::custom("expected guild default_message_notifications"))
-            .and_then(DefaultMessageNotificationLevel::deserialize)
-            .map_err(DeError::custom)?;
         let emojis = map
             .remove("emojis")
             .ok_or_else(|| DeError::custom("expected guild emojis"))
             .and_then(emojis::deserialize)
             .map_err(DeError::custom)?;
-        let features = map
-            .remove("features")
-            .ok_or(Error::Other("expected guild features"))
-            .and_then(from_value::<Vec<String>>)
-            .map_err(DeError::custom)?;
-        let icon = match map.remove("icon") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let id = map
-            .remove("id")
-            .ok_or_else(|| DeError::custom("expected guild id"))
-            .and_then(GuildId::deserialize)
-            .map_err(DeError::custom)?;
-        let mfa_level = map
-            .remove("mfa_level")
-            .ok_or_else(|| DeError::custom("expected guild mfa_level"))
-            .and_then(MfaLevel::deserialize)
-            .map_err(DeError::custom)?;
-        let name = map
-            .remove("name")
-            .ok_or_else(|| DeError::custom("expected guild name"))
-            .and_then(String::deserialize)
-            .map_err(DeError::custom)?;
-        let owner_id = map
-            .remove("owner_id")
-            .ok_or_else(|| DeError::custom("expected guild owner_id"))
-            .and_then(UserId::deserialize)
-            .map_err(DeError::custom)?;
+
         let roles = map
             .remove("roles")
             .ok_or_else(|| DeError::custom("expected guild roles"))
             .and_then(roles::deserialize)
             .map_err(DeError::custom)?;
-        let splash = match map.remove("splash") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let verification_level = map
-            .remove("verification_level")
-            .ok_or_else(|| DeError::custom("expected guild verification_level"))
-            .and_then(VerificationLevel::deserialize)
-            .map_err(DeError::custom)?;
-        let description = match map.remove("description") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let premium_tier = match map.remove("premium_tier") {
-            Some(v) => PremiumTier::deserialize(v).map_err(DeError::custom)?,
-            None => PremiumTier::default(),
-        };
+
         let premium_subscription_count = match map.remove("premium_subscription_count") {
             #[cfg(not(feature = "simd_json"))]
             Some(Value::Null) | None => 0,
@@ -1741,104 +1681,6 @@ impl<'de> Deserialize<'de> for PartialGuild {
             Some(Value::Static(StaticNode::Null)) | None => 0,
             Some(v) => u64::deserialize(v).map_err(DeError::custom)?,
         };
-        let banner = match map.remove("banner") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let vanity_url_code = match map.remove("vanity_url_code") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-        let system_channel_id = match map.remove("system_channel_id") {
-            Some(v) => Option::<ChannelId>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let approximate_member_count = map
-            .remove("approximate_member_count")
-            .map(u64::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let approximate_presence_count = map
-            .remove("approximate_presence_count")
-            .map(u64::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let owner = map
-            .remove("owner")
-            .map(bool::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?
-            .unwrap_or_default();
-
-        let nsfw_level = map
-            .remove("nsfw_level")
-            .ok_or_else(|| DeError::custom("expected nsfw_level"))
-            .and_then(NsfwLevel::deserialize)
-            .map_err(DeError::custom)?;
-
-        let max_video_channel_users = map
-            .remove("max_video_channel_users")
-            .map(u64::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
-
-        let max_presences = match map.remove("max_presences") {
-            Some(v) => Option::<u64>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let max_members =
-            map.remove("max_members").map(u64::deserialize).transpose().map_err(DeError::custom)?;
-
-        let discovery_splash = match map.remove("discovery_splash") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let application_id = match map.remove("application_id") {
-            Some(v) => Option::<ApplicationId>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let public_updates_channel_id = match map.remove("public_updates_channel_id") {
-            Some(v) => Option::<ChannelId>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let system_channel_flags = map
-            .remove("system_channel_flags")
-            .ok_or_else(|| DeError::custom("expected system_channel_flags"))
-            .and_then(SystemChannelFlags::deserialize)
-            .map_err(DeError::custom)?;
-
-        let rules_channel_id = match map.remove("rules_channel_id") {
-            Some(v) => Option::<ChannelId>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let widget_enabled = match map.remove("widget_enabled") {
-            Some(v) => Option::<bool>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let widget_channel_id = match map.remove("widget_channel_id") {
-            Some(v) => Option::<ChannelId>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let permissions = match map.remove("permissions") {
-            Some(v) => Option::<String>::deserialize(v).map_err(DeError::custom)?,
-            None => None,
-        };
-
-        let welcome_screen = map
-            .remove("welcome_screen")
-            .map(GuildWelcomeScreen::deserialize)
-            .transpose()
-            .map_err(DeError::custom)?;
 
         let stickers = map
             .remove("stickers")
@@ -1847,42 +1689,49 @@ impl<'de> Deserialize<'de> for PartialGuild {
             .map_err(DeError::custom)?;
 
         Ok(Self {
-            application_id,
             id,
-            afk_channel_id,
-            afk_timeout,
-            default_message_notifications,
-            widget_enabled,
-            widget_channel_id,
             emojis,
-            features,
-            icon,
-            mfa_level,
-            name,
-            owner_id,
-            owner,
             roles,
-            splash,
-            discovery_splash,
-            system_channel_id,
-            system_channel_flags,
-            rules_channel_id,
-            public_updates_channel_id,
-            verification_level,
-            description,
-            premium_tier,
             premium_subscription_count,
-            banner,
-            vanity_url_code,
-            welcome_screen,
-            approximate_member_count,
-            approximate_presence_count,
-            nsfw_level,
-            max_video_channel_users,
-            max_presences,
-            max_members,
-            permissions,
             stickers,
+            afk_channel_id: remove_from_map_opt(&mut map, "afk_channel_id")?.flatten(),
+            afk_timeout: remove_from_map(&mut map, "afk_timeout")?,
+            application_id: remove_from_map_opt(&mut map, "application_id")?.flatten(),
+            default_message_notifications: remove_from_map(
+                &mut map,
+                "default_message_notifications",
+            )?,
+            features: remove_from_map(&mut map, "features")?,
+            widget_enabled: remove_from_map_opt(&mut map, "widget_enabled")?.flatten(),
+            widget_channel_id: remove_from_map_opt(&mut map, "widget_channel_id")?.flatten(),
+            icon: remove_from_map_opt(&mut map, "icon")?.flatten(),
+            mfa_level: remove_from_map(&mut map, "mfa_level")?,
+            name: remove_from_map(&mut map, "name")?,
+            owner_id: remove_from_map(&mut map, "owner_id")?,
+            owner: remove_from_map_opt(&mut map, "owner")?.unwrap_or_default(),
+            splash: remove_from_map_opt(&mut map, "splash")?.flatten(),
+            discovery_splash: remove_from_map_opt(&mut map, "discovery_splash")?.flatten(),
+            system_channel_id: remove_from_map_opt(&mut map, "system_channel_id")?.flatten(),
+            system_channel_flags: remove_from_map(&mut map, "system_channel_flags")?,
+            rules_channel_id: remove_from_map_opt(&mut map, "rules_channel_id")?.flatten(),
+            public_updates_channel_id: remove_from_map_opt(&mut map, "public_updates_channel_id")?
+                .flatten(),
+            verification_level: remove_from_map(&mut map, "verification_level")?,
+            description: remove_from_map_opt(&mut map, "description")?.flatten(),
+            premium_tier: remove_from_map_opt(&mut map, "premium_tier")?.unwrap_or_default(),
+            banner: remove_from_map_opt(&mut map, "banner")?.flatten(),
+            vanity_url_code: remove_from_map_opt(&mut map, "vanity_url_code")?.flatten(),
+            welcome_screen: remove_from_map_opt(&mut map, "welcome_screen")?,
+            approximate_member_count: remove_from_map_opt(&mut map, "approximate_member_count")?,
+            approximate_presence_count: remove_from_map_opt(
+                &mut map,
+                "approximate_presence_count",
+            )?,
+            nsfw_level: remove_from_map(&mut map, "nsfw_level")?,
+            max_video_channel_users: remove_from_map(&mut map, "max_video_channel_users")?,
+            max_presences: remove_from_map_opt(&mut map, "max_presences")?.flatten(),
+            max_members: remove_from_map_opt(&mut map, "max_members")?.flatten(),
+            permissions: remove_from_map_opt(&mut map, "permissions")?.unwrap_or_default(),
         })
     }
 }
diff --git a/src/model/permissions.rs b/src/model/permissions.rs
index 72cc86d03bf..37d7ae0855b 100644
--- a/src/model/permissions.rs
+++ b/src/model/permissions.rs
@@ -41,9 +41,10 @@
 //! [Manage Roles]: Permissions::MANAGE_ROLES
 //! [Manage Webhooks]: Permissions::MANAGE_WEBHOOKS
 
+#[cfg(feature = "model")]
 use std::fmt;
 
-use serde::de::{Deserialize, Deserializer};
+use serde::de::{Deserialize, Deserializer, Error as DeError};
 use serde::ser::{Serialize, Serializer};
 
 /// This macro generates the [`Permissions::get_permission_names`] method.
@@ -788,32 +789,15 @@ impl Permissions {
 
 impl<'de> Deserialize<'de> for Permissions {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        struct StringVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for StringVisitor {
-            type Value = Permissions;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("permissions string")
-            }
+        let permissions_str = String::deserialize(deserializer)?;
+        let permissions_num = permissions_str.parse().map_err(DeError::custom)?;
 
-            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                let value = v.parse().map_err(E::custom)?;
-                Ok(Permissions::from_bits_truncate(value))
-            }
-        }
-        deserializer.deserialize_str(StringVisitor)
+        Ok(Permissions::from_bits_truncate(permissions_num))
     }
 }
 
 impl Serialize for Permissions {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         serializer.collect_str(&self.bits())
     }
 }
diff --git a/src/model/utils.rs b/src/model/utils.rs
index 0d36d2ce451..9210e7ebb01 100644
--- a/src/model/utils.rs
+++ b/src/model/utils.rs
@@ -12,6 +12,7 @@ use super::prelude::*;
 use crate::cache::Cache;
 #[cfg(feature = "cache")]
 use crate::internal::prelude::*;
+use crate::json::from_number;
 use crate::model::application::command::CommandOptionType;
 use crate::model::application::interaction::application_command::{
     CommandDataOption,
@@ -58,6 +59,16 @@ where
     remove_from_map_opt(map, key)?.ok_or_else(|| serde::de::Error::missing_field(key))
 }
 
+pub fn add_guild_id_to_map(map: &mut JsonMap, key: &str, id: GuildId) {
+    if let Some(array) = map.get_mut(key).and_then(Value::as_array_mut) {
+        for value in array {
+            if let Some(item) = value.as_object_mut() {
+                item.insert("guild_id".to_string(), from_number(id.0));
+            }
+        }
+    }
+}
+
 /// Used with `#[serde(with = "emojis")]`
 pub mod emojis {
     use std::collections::HashMap;