Restore Rust 1.34.2 compatibility

2019-10-23 02:09:34 +02:00 · 2019-10-23 02:09:34 +02:00 · 60c817e1b0
commit 60c817e1b0
parent c925cd13f1
11 changed files with 412 additions and 303 deletions
--- a/README.md
+++ b/README.md
@ -6,7 +6,7 @@

 ## Minimum Rust version

-ruma-events requires Rust 1.34 or later.
+ruma-events requires Rust 1.34.2 or later.

 ## Documentation

--- a/ruma-events-macros/src/parse.rs
+++ b/ruma-events-macros/src/parse.rs
@ -215,20 +215,20 @@ impl Parse for RumaEventField {
                    .into_iter()
                    .collect();

-                Ok(Self::InlineStruct(FieldInlineStruct {
+                Ok(RumaEventField::InlineStruct(FieldInlineStruct {
                    attrs,
                    member,
                    colon_token,
                    fields,
                }))
            }
-            "content_type_alias" => Ok(Self::Block(FieldBlock {
+            "content_type_alias" => Ok(RumaEventField::Block(FieldBlock {
                attrs: input.call(Attribute::parse_outer)?,
                member: input.parse()?,
                colon_token: input.parse()?,
                typedef: input.parse()?,
            })),
-            _ => Ok(Self::Value(input.parse()?)),
+            _ => Ok(RumaEventField::Value(input.parse()?)),
        }
    }
 }
--- a/src/collections/all.rs
+++ b/src/collections/all.rs
@ -343,54 +343,60 @@ impl TryFromRaw for Event {
        use raw::Event::*;

        match raw {
-            CallAnswer(c) => conv(CallAnswer, Self::CallAnswer, c),
-            CallCandidates(c) => conv(CallCandidates, Self::CallCandidates, c),
-            CallHangup(c) => conv(CallHangup, Self::CallHangup, c),
-            CallInvite(c) => conv(CallInvite, Self::CallInvite, c),
-            Direct(c) => conv(Direct, Self::Direct, c),
-            Dummy(c) => conv(Dummy, Self::Dummy, c),
-            ForwardedRoomKey(c) => conv(ForwardedRoomKey, Self::ForwardedRoomKey, c),
-            FullyRead(c) => conv(FullyRead, Self::FullyRead, c),
-            IgnoredUserList(c) => conv(IgnoredUserList, Self::IgnoredUserList, c),
-            KeyVerificationAccept(c) => conv(KeyVerificationAccept, Self::KeyVerificationAccept, c),
-            KeyVerificationCancel(c) => conv(KeyVerificationCancel, Self::KeyVerificationCancel, c),
-            KeyVerificationKey(c) => conv(KeyVerificationKey, Self::KeyVerificationKey, c),
-            KeyVerificationMac(c) => conv(KeyVerificationMac, Self::KeyVerificationMac, c),
-            KeyVerificationRequest(c) => {
-                conv(KeyVerificationRequest, Self::KeyVerificationRequest, c)
+            CallAnswer(c) => conv(CallAnswer, Event::CallAnswer, c),
+            CallCandidates(c) => conv(CallCandidates, Event::CallCandidates, c),
+            CallHangup(c) => conv(CallHangup, Event::CallHangup, c),
+            CallInvite(c) => conv(CallInvite, Event::CallInvite, c),
+            Direct(c) => conv(Direct, Event::Direct, c),
+            Dummy(c) => conv(Dummy, Event::Dummy, c),
+            ForwardedRoomKey(c) => conv(ForwardedRoomKey, Event::ForwardedRoomKey, c),
+            FullyRead(c) => conv(FullyRead, Event::FullyRead, c),
+            IgnoredUserList(c) => conv(IgnoredUserList, Event::IgnoredUserList, c),
+            KeyVerificationAccept(c) => {
+                conv(KeyVerificationAccept, Event::KeyVerificationAccept, c)
            }
-            KeyVerificationStart(c) => conv(KeyVerificationStart, Self::KeyVerificationStart, c),
-            Presence(c) => conv(Presence, Self::Presence, c),
-            PushRules(c) => conv(PushRules, Self::PushRules, c),
-            Receipt(c) => conv(Receipt, Self::Receipt, c),
-            RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c),
-            RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c),
-            RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c),
-            RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c),
-            RoomEncrypted(c) => conv(RoomEncrypted, Self::RoomEncrypted, c),
-            RoomEncryption(c) => conv(RoomEncryption, Self::RoomEncryption, c),
-            RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c),
-            RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c),
-            RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c),
-            RoomMember(c) => conv(RoomMember, Self::RoomMember, c),
-            RoomMessage(c) => conv(RoomMessage, Self::RoomMessage, c),
-            RoomMessageFeedback(c) => conv(RoomMessageFeedback, Self::RoomMessageFeedback, c),
-            RoomName(c) => conv(RoomName, Self::RoomName, c),
-            RoomPinnedEvents(c) => conv(RoomPinnedEvents, Self::RoomPinnedEvents, c),
-            RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c),
-            RoomRedaction(c) => conv(RoomRedaction, Self::RoomRedaction, c),
-            RoomServerAcl(c) => conv(RoomServerAcl, Self::RoomServerAcl, c),
-            RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c),
-            RoomTombstone(c) => conv(RoomTombstone, Self::RoomTombstone, c),
-            RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c),
-            RoomKey(c) => conv(RoomKey, Self::RoomKey, c),
-            RoomKeyRequest(c) => conv(RoomKeyRequest, Self::RoomKeyRequest, c),
-            Sticker(c) => conv(Sticker, Self::Sticker, c),
-            Tag(c) => conv(Tag, Self::Tag, c),
-            Typing(c) => conv(Typing, Self::Typing, c),
-            Custom(c) => Ok(Self::Custom(c)),
-            CustomRoom(c) => Ok(Self::CustomRoom(c)),
-            CustomState(c) => Ok(Self::CustomState(c)),
+            KeyVerificationCancel(c) => {
+                conv(KeyVerificationCancel, Event::KeyVerificationCancel, c)
+            }
+            KeyVerificationKey(c) => conv(KeyVerificationKey, Event::KeyVerificationKey, c),
+            KeyVerificationMac(c) => conv(KeyVerificationMac, Event::KeyVerificationMac, c),
+            KeyVerificationRequest(c) => {
+                conv(KeyVerificationRequest, Event::KeyVerificationRequest, c)
+            }
+            KeyVerificationStart(c) => conv(KeyVerificationStart, Event::KeyVerificationStart, c),
+            Presence(c) => conv(Presence, Event::Presence, c),
+            PushRules(c) => conv(PushRules, Event::PushRules, c),
+            Receipt(c) => conv(Receipt, Event::Receipt, c),
+            RoomAliases(c) => conv(RoomAliases, Event::RoomAliases, c),
+            RoomAvatar(c) => conv(RoomAvatar, Event::RoomAvatar, c),
+            RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Event::RoomCanonicalAlias, c),
+            RoomCreate(c) => conv(RoomCreate, Event::RoomCreate, c),
+            RoomEncrypted(c) => conv(RoomEncrypted, Event::RoomEncrypted, c),
+            RoomEncryption(c) => conv(RoomEncryption, Event::RoomEncryption, c),
+            RoomGuestAccess(c) => conv(RoomGuestAccess, Event::RoomGuestAccess, c),
+            RoomHistoryVisibility(c) => {
+                conv(RoomHistoryVisibility, Event::RoomHistoryVisibility, c)
+            }
+            RoomJoinRules(c) => conv(RoomJoinRules, Event::RoomJoinRules, c),
+            RoomMember(c) => conv(RoomMember, Event::RoomMember, c),
+            RoomMessage(c) => conv(RoomMessage, Event::RoomMessage, c),
+            RoomMessageFeedback(c) => conv(RoomMessageFeedback, Event::RoomMessageFeedback, c),
+            RoomName(c) => conv(RoomName, Event::RoomName, c),
+            RoomPinnedEvents(c) => conv(RoomPinnedEvents, Event::RoomPinnedEvents, c),
+            RoomPowerLevels(c) => conv(RoomPowerLevels, Event::RoomPowerLevels, c),
+            RoomRedaction(c) => conv(RoomRedaction, Event::RoomRedaction, c),
+            RoomServerAcl(c) => conv(RoomServerAcl, Event::RoomServerAcl, c),
+            RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Event::RoomThirdPartyInvite, c),
+            RoomTombstone(c) => conv(RoomTombstone, Event::RoomTombstone, c),
+            RoomTopic(c) => conv(RoomTopic, Event::RoomTopic, c),
+            RoomKey(c) => conv(RoomKey, Event::RoomKey, c),
+            RoomKeyRequest(c) => conv(RoomKeyRequest, Event::RoomKeyRequest, c),
+            Sticker(c) => conv(Sticker, Event::Sticker, c),
+            Tag(c) => conv(Tag, Event::Tag, c),
+            Typing(c) => conv(Typing, Event::Typing, c),
+            Custom(c) => Ok(Event::Custom(c)),
+            CustomRoom(c) => Ok(Event::CustomRoom(c)),
+            CustomState(c) => Ok(Event::CustomState(c)),
        }
    }
 }
@ -404,33 +410,37 @@ impl TryFromRaw for RoomEvent {
        use raw::RoomEvent::*;

        match raw {
-            CallAnswer(c) => conv(CallAnswer, Self::CallAnswer, c),
-            CallCandidates(c) => conv(CallCandidates, Self::CallCandidates, c),
-            CallHangup(c) => conv(CallHangup, Self::CallHangup, c),
-            CallInvite(c) => conv(CallInvite, Self::CallInvite, c),
-            RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c),
-            RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c),
-            RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c),
-            RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c),
-            RoomEncrypted(c) => conv(RoomEncrypted, Self::RoomEncrypted, c),
-            RoomEncryption(c) => conv(RoomEncryption, Self::RoomEncryption, c),
-            RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c),
-            RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c),
-            RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c),
-            RoomMember(c) => conv(RoomMember, Self::RoomMember, c),
-            RoomMessage(c) => conv(RoomMessage, Self::RoomMessage, c),
-            RoomMessageFeedback(c) => conv(RoomMessageFeedback, Self::RoomMessageFeedback, c),
-            RoomName(c) => conv(RoomName, Self::RoomName, c),
-            RoomPinnedEvents(c) => conv(RoomPinnedEvents, Self::RoomPinnedEvents, c),
-            RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c),
-            RoomRedaction(c) => conv(RoomRedaction, Self::RoomRedaction, c),
-            RoomServerAcl(c) => conv(RoomServerAcl, Self::RoomServerAcl, c),
-            RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c),
-            RoomTombstone(c) => conv(RoomTombstone, Self::RoomTombstone, c),
-            RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c),
-            Sticker(c) => conv(Sticker, Self::Sticker, c),
-            CustomRoom(c) => Ok(Self::CustomRoom(c)),
-            CustomState(c) => Ok(Self::CustomState(c)),
+            CallAnswer(c) => conv(CallAnswer, RoomEvent::CallAnswer, c),
+            CallCandidates(c) => conv(CallCandidates, RoomEvent::CallCandidates, c),
+            CallHangup(c) => conv(CallHangup, RoomEvent::CallHangup, c),
+            CallInvite(c) => conv(CallInvite, RoomEvent::CallInvite, c),
+            RoomAliases(c) => conv(RoomAliases, RoomEvent::RoomAliases, c),
+            RoomAvatar(c) => conv(RoomAvatar, RoomEvent::RoomAvatar, c),
+            RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, RoomEvent::RoomCanonicalAlias, c),
+            RoomCreate(c) => conv(RoomCreate, RoomEvent::RoomCreate, c),
+            RoomEncrypted(c) => conv(RoomEncrypted, RoomEvent::RoomEncrypted, c),
+            RoomEncryption(c) => conv(RoomEncryption, RoomEvent::RoomEncryption, c),
+            RoomGuestAccess(c) => conv(RoomGuestAccess, RoomEvent::RoomGuestAccess, c),
+            RoomHistoryVisibility(c) => {
+                conv(RoomHistoryVisibility, RoomEvent::RoomHistoryVisibility, c)
+            }
+            RoomJoinRules(c) => conv(RoomJoinRules, RoomEvent::RoomJoinRules, c),
+            RoomMember(c) => conv(RoomMember, RoomEvent::RoomMember, c),
+            RoomMessage(c) => conv(RoomMessage, RoomEvent::RoomMessage, c),
+            RoomMessageFeedback(c) => conv(RoomMessageFeedback, RoomEvent::RoomMessageFeedback, c),
+            RoomName(c) => conv(RoomName, RoomEvent::RoomName, c),
+            RoomPinnedEvents(c) => conv(RoomPinnedEvents, RoomEvent::RoomPinnedEvents, c),
+            RoomPowerLevels(c) => conv(RoomPowerLevels, RoomEvent::RoomPowerLevels, c),
+            RoomRedaction(c) => conv(RoomRedaction, RoomEvent::RoomRedaction, c),
+            RoomServerAcl(c) => conv(RoomServerAcl, RoomEvent::RoomServerAcl, c),
+            RoomThirdPartyInvite(c) => {
+                conv(RoomThirdPartyInvite, RoomEvent::RoomThirdPartyInvite, c)
+            }
+            RoomTombstone(c) => conv(RoomTombstone, RoomEvent::RoomTombstone, c),
+            RoomTopic(c) => conv(RoomTopic, RoomEvent::RoomTopic, c),
+            Sticker(c) => conv(Sticker, RoomEvent::Sticker, c),
+            CustomRoom(c) => Ok(RoomEvent::CustomRoom(c)),
+            CustomState(c) => Ok(RoomEvent::CustomState(c)),
        }
    }
 }
@ -444,23 +454,27 @@ impl TryFromRaw for StateEvent {
        use raw::StateEvent::*;

        match raw {
-            RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c),
-            RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c),
-            RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c),
-            RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c),
-            RoomEncryption(c) => conv(RoomEncryption, Self::RoomEncryption, c),
-            RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c),
-            RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c),
-            RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c),
-            RoomMember(c) => conv(RoomMember, Self::RoomMember, c),
-            RoomName(c) => conv(RoomName, Self::RoomName, c),
-            RoomPinnedEvents(c) => conv(RoomPinnedEvents, Self::RoomPinnedEvents, c),
-            RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c),
-            RoomServerAcl(c) => conv(RoomServerAcl, Self::RoomServerAcl, c),
-            RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c),
-            RoomTombstone(c) => conv(RoomTombstone, Self::RoomTombstone, c),
-            RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c),
-            CustomState(c) => Ok(Self::CustomState(c)),
+            RoomAliases(c) => conv(RoomAliases, StateEvent::RoomAliases, c),
+            RoomAvatar(c) => conv(RoomAvatar, StateEvent::RoomAvatar, c),
+            RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, StateEvent::RoomCanonicalAlias, c),
+            RoomCreate(c) => conv(RoomCreate, StateEvent::RoomCreate, c),
+            RoomEncryption(c) => conv(RoomEncryption, StateEvent::RoomEncryption, c),
+            RoomGuestAccess(c) => conv(RoomGuestAccess, StateEvent::RoomGuestAccess, c),
+            RoomHistoryVisibility(c) => {
+                conv(RoomHistoryVisibility, StateEvent::RoomHistoryVisibility, c)
+            }
+            RoomJoinRules(c) => conv(RoomJoinRules, StateEvent::RoomJoinRules, c),
+            RoomMember(c) => conv(RoomMember, StateEvent::RoomMember, c),
+            RoomName(c) => conv(RoomName, StateEvent::RoomName, c),
+            RoomPinnedEvents(c) => conv(RoomPinnedEvents, StateEvent::RoomPinnedEvents, c),
+            RoomPowerLevels(c) => conv(RoomPowerLevels, StateEvent::RoomPowerLevels, c),
+            RoomServerAcl(c) => conv(RoomServerAcl, StateEvent::RoomServerAcl, c),
+            RoomThirdPartyInvite(c) => {
+                conv(RoomThirdPartyInvite, StateEvent::RoomThirdPartyInvite, c)
+            }
+            RoomTombstone(c) => conv(RoomTombstone, StateEvent::RoomTombstone, c),
+            RoomTopic(c) => conv(RoomTopic, StateEvent::RoomTopic, c),
+            CustomState(c) => Ok(StateEvent::CustomState(c)),
        }
    }
 }
--- a/src/collections/only.rs
+++ b/src/collections/only.rs
@ -139,27 +139,31 @@ impl TryFromRaw for Event {
        use raw::Event::*;

        match raw {
-            Direct(c) => conv(Direct, Self::Direct, c),
-            Dummy(c) => conv(Dummy, Self::Dummy, c),
-            ForwardedRoomKey(c) => conv(ForwardedRoomKey, Self::ForwardedRoomKey, c),
-            FullyRead(c) => conv(FullyRead, Self::FullyRead, c),
-            KeyVerificationAccept(c) => conv(KeyVerificationAccept, Self::KeyVerificationAccept, c),
-            KeyVerificationCancel(c) => conv(KeyVerificationCancel, Self::KeyVerificationCancel, c),
-            KeyVerificationKey(c) => conv(KeyVerificationKey, Self::KeyVerificationKey, c),
-            KeyVerificationMac(c) => conv(KeyVerificationMac, Self::KeyVerificationMac, c),
-            KeyVerificationRequest(c) => {
-                conv(KeyVerificationRequest, Self::KeyVerificationRequest, c)
+            Direct(c) => conv(Direct, Event::Direct, c),
+            Dummy(c) => conv(Dummy, Event::Dummy, c),
+            ForwardedRoomKey(c) => conv(ForwardedRoomKey, Event::ForwardedRoomKey, c),
+            FullyRead(c) => conv(FullyRead, Event::FullyRead, c),
+            KeyVerificationAccept(c) => {
+                conv(KeyVerificationAccept, Event::KeyVerificationAccept, c)
            }
-            KeyVerificationStart(c) => conv(KeyVerificationStart, Self::KeyVerificationStart, c),
-            IgnoredUserList(c) => conv(IgnoredUserList, Self::IgnoredUserList, c),
-            Presence(c) => conv(Presence, Self::Presence, c),
-            PushRules(c) => conv(PushRules, Self::PushRules, c),
-            RoomKey(c) => conv(RoomKey, Self::RoomKey, c),
-            RoomKeyRequest(c) => conv(RoomKeyRequest, Self::RoomKeyRequest, c),
-            Receipt(c) => conv(Receipt, Self::Receipt, c),
-            Tag(c) => conv(Tag, Self::Tag, c),
-            Typing(c) => conv(Typing, Self::Typing, c),
-            Custom(c) => Ok(Self::Custom(c)),
+            KeyVerificationCancel(c) => {
+                conv(KeyVerificationCancel, Event::KeyVerificationCancel, c)
+            }
+            KeyVerificationKey(c) => conv(KeyVerificationKey, Event::KeyVerificationKey, c),
+            KeyVerificationMac(c) => conv(KeyVerificationMac, Event::KeyVerificationMac, c),
+            KeyVerificationRequest(c) => {
+                conv(KeyVerificationRequest, Event::KeyVerificationRequest, c)
+            }
+            KeyVerificationStart(c) => conv(KeyVerificationStart, Event::KeyVerificationStart, c),
+            IgnoredUserList(c) => conv(IgnoredUserList, Event::IgnoredUserList, c),
+            Presence(c) => conv(Presence, Event::Presence, c),
+            PushRules(c) => conv(PushRules, Event::PushRules, c),
+            RoomKey(c) => conv(RoomKey, Event::RoomKey, c),
+            RoomKeyRequest(c) => conv(RoomKeyRequest, Event::RoomKeyRequest, c),
+            Receipt(c) => conv(Receipt, Event::Receipt, c),
+            Tag(c) => conv(Tag, Event::Tag, c),
+            Typing(c) => conv(Typing, Event::Typing, c),
+            Custom(c) => Ok(Event::Custom(c)),
        }
    }
 }
@ -173,16 +177,16 @@ impl TryFromRaw for RoomEvent {
        use raw::RoomEvent::*;

        match raw {
-            CallAnswer(c) => conv(CallAnswer, Self::CallAnswer, c),
-            CallCandidates(c) => conv(CallCandidates, Self::CallCandidates, c),
-            CallHangup(c) => conv(CallHangup, Self::CallHangup, c),
-            CallInvite(c) => conv(CallInvite, Self::CallInvite, c),
-            RoomEncrypted(c) => conv(RoomEncrypted, Self::RoomEncrypted, c),
-            RoomMessage(c) => conv(RoomMessage, Self::RoomMessage, c),
-            RoomMessageFeedback(c) => conv(RoomMessageFeedback, Self::RoomMessageFeedback, c),
-            RoomRedaction(c) => conv(RoomRedaction, Self::RoomRedaction, c),
-            Sticker(c) => conv(Sticker, Self::Sticker, c),
-            CustomRoom(c) => Ok(Self::CustomRoom(c)),
+            CallAnswer(c) => conv(CallAnswer, RoomEvent::CallAnswer, c),
+            CallCandidates(c) => conv(CallCandidates, RoomEvent::CallCandidates, c),
+            CallHangup(c) => conv(CallHangup, RoomEvent::CallHangup, c),
+            CallInvite(c) => conv(CallInvite, RoomEvent::CallInvite, c),
+            RoomEncrypted(c) => conv(RoomEncrypted, RoomEvent::RoomEncrypted, c),
+            RoomMessage(c) => conv(RoomMessage, RoomEvent::RoomMessage, c),
+            RoomMessageFeedback(c) => conv(RoomMessageFeedback, RoomEvent::RoomMessageFeedback, c),
+            RoomRedaction(c) => conv(RoomRedaction, RoomEvent::RoomRedaction, c),
+            Sticker(c) => conv(Sticker, RoomEvent::Sticker, c),
+            CustomRoom(c) => Ok(RoomEvent::CustomRoom(c)),
        }
    }
 }
--- a/src/collections/raw/all.rs
+++ b/src/collections/raw/all.rs
@ -347,85 +347,95 @@ impl<'de> Deserialize<'de> for Event {
        let event_type = get_field(&value, "type")?;

        match event_type {
-            CallAnswer => from_value(value).map(Self::CallAnswer).map_err(conv_err),
+            CallAnswer => from_value(value).map(Event::CallAnswer).map_err(conv_err),
            CallCandidates => from_value(value)
-                .map(Self::CallCandidates)
+                .map(Event::CallCandidates)
                .map_err(conv_err),
-            CallHangup => from_value(value).map(Self::CallHangup).map_err(conv_err),
-            CallInvite => from_value(value).map(Self::CallInvite).map_err(conv_err),
-            Direct => from_value(value).map(Self::Direct).map_err(conv_err),
-            Dummy => from_value(value).map(Self::Dummy).map_err(conv_err),
+            CallHangup => from_value(value).map(Event::CallHangup).map_err(conv_err),
+            CallInvite => from_value(value).map(Event::CallInvite).map_err(conv_err),
+            Direct => from_value(value).map(Event::Direct).map_err(conv_err),
+            Dummy => from_value(value).map(Event::Dummy).map_err(conv_err),
            ForwardedRoomKey => from_value(value)
-                .map(Self::ForwardedRoomKey)
+                .map(Event::ForwardedRoomKey)
                .map_err(conv_err),
-            FullyRead => from_value(value).map(Self::FullyRead).map_err(conv_err),
+            FullyRead => from_value(value).map(Event::FullyRead).map_err(conv_err),
            IgnoredUserList => from_value(value)
-                .map(Self::IgnoredUserList)
+                .map(Event::IgnoredUserList)
                .map_err(conv_err),
            KeyVerificationAccept => from_value(value)
-                .map(Self::KeyVerificationAccept)
+                .map(Event::KeyVerificationAccept)
                .map_err(conv_err),
            KeyVerificationCancel => from_value(value)
-                .map(Self::KeyVerificationCancel)
+                .map(Event::KeyVerificationCancel)
                .map_err(conv_err),
            KeyVerificationKey => from_value(value)
-                .map(Self::KeyVerificationKey)
+                .map(Event::KeyVerificationKey)
                .map_err(conv_err),
            KeyVerificationMac => from_value(value)
-                .map(Self::KeyVerificationMac)
+                .map(Event::KeyVerificationMac)
                .map_err(conv_err),
            KeyVerificationRequest => from_value(value)
-                .map(Self::KeyVerificationRequest)
+                .map(Event::KeyVerificationRequest)
                .map_err(conv_err),
            KeyVerificationStart => from_value(value)
-                .map(Self::KeyVerificationStart)
+                .map(Event::KeyVerificationStart)
                .map_err(conv_err),
-            Presence => from_value(value).map(Self::Presence).map_err(conv_err),
-            PushRules => from_value(value).map(Self::PushRules).map_err(conv_err),
-            Receipt => from_value(value).map(Self::Receipt).map_err(conv_err),
-            RoomAliases => from_value(value).map(Self::RoomAliases).map_err(conv_err),
-            RoomAvatar => from_value(value).map(Self::RoomAvatar).map_err(conv_err),
+            Presence => from_value(value).map(Event::Presence).map_err(conv_err),
+            PushRules => from_value(value).map(Event::PushRules).map_err(conv_err),
+            Receipt => from_value(value).map(Event::Receipt).map_err(conv_err),
+            RoomAliases => from_value(value).map(Event::RoomAliases).map_err(conv_err),
+            RoomAvatar => from_value(value).map(Event::RoomAvatar).map_err(conv_err),
            RoomCanonicalAlias => from_value(value)
-                .map(Self::RoomCanonicalAlias)
+                .map(Event::RoomCanonicalAlias)
+                .map_err(conv_err),
+            RoomCreate => from_value(value).map(Event::RoomCreate).map_err(conv_err),
+            RoomEncrypted => from_value(value)
+                .map(Event::RoomEncrypted)
                .map_err(conv_err),
-            RoomCreate => from_value(value).map(Self::RoomCreate).map_err(conv_err),
-            RoomEncrypted => from_value(value).map(Self::RoomEncrypted).map_err(conv_err),
            RoomEncryption => from_value(value)
-                .map(Self::RoomEncryption)
+                .map(Event::RoomEncryption)
                .map_err(conv_err),
            RoomGuestAccess => from_value(value)
-                .map(Self::RoomGuestAccess)
+                .map(Event::RoomGuestAccess)
                .map_err(conv_err),
            RoomHistoryVisibility => from_value(value)
-                .map(Self::RoomHistoryVisibility)
+                .map(Event::RoomHistoryVisibility)
                .map_err(conv_err),
-            RoomJoinRules => from_value(value).map(Self::RoomJoinRules).map_err(conv_err),
-            RoomMember => from_value(value).map(Self::RoomMember).map_err(conv_err),
-            RoomMessage => from_value(value).map(Self::RoomMessage).map_err(conv_err),
+            RoomJoinRules => from_value(value)
+                .map(Event::RoomJoinRules)
+                .map_err(conv_err),
+            RoomMember => from_value(value).map(Event::RoomMember).map_err(conv_err),
+            RoomMessage => from_value(value).map(Event::RoomMessage).map_err(conv_err),
            RoomMessageFeedback => from_value(value)
-                .map(Self::RoomMessageFeedback)
+                .map(Event::RoomMessageFeedback)
                .map_err(conv_err),
-            RoomName => from_value(value).map(Self::RoomName).map_err(conv_err),
+            RoomName => from_value(value).map(Event::RoomName).map_err(conv_err),
            RoomPinnedEvents => from_value(value)
-                .map(Self::RoomPinnedEvents)
+                .map(Event::RoomPinnedEvents)
                .map_err(conv_err),
            RoomPowerLevels => from_value(value)
-                .map(Self::RoomPowerLevels)
+                .map(Event::RoomPowerLevels)
+                .map_err(conv_err),
+            RoomRedaction => from_value(value)
+                .map(Event::RoomRedaction)
+                .map_err(conv_err),
+            RoomServerAcl => from_value(value)
+                .map(Event::RoomServerAcl)
                .map_err(conv_err),
-            RoomRedaction => from_value(value).map(Self::RoomRedaction).map_err(conv_err),
-            RoomServerAcl => from_value(value).map(Self::RoomServerAcl).map_err(conv_err),
            RoomThirdPartyInvite => from_value(value)
-                .map(Self::RoomThirdPartyInvite)
+                .map(Event::RoomThirdPartyInvite)
                .map_err(conv_err),
-            RoomTombstone => from_value(value).map(Self::RoomTombstone).map_err(conv_err),
-            RoomTopic => from_value(value).map(Self::RoomTopic).map_err(conv_err),
-            RoomKey => from_value(value).map(Self::RoomKey).map_err(conv_err),
+            RoomTombstone => from_value(value)
+                .map(Event::RoomTombstone)
+                .map_err(conv_err),
+            RoomTopic => from_value(value).map(Event::RoomTopic).map_err(conv_err),
+            RoomKey => from_value(value).map(Event::RoomKey).map_err(conv_err),
            RoomKeyRequest => from_value(value)
-                .map(Self::RoomKeyRequest)
+                .map(Event::RoomKeyRequest)
                .map_err(conv_err),
-            Sticker => from_value(value).map(Self::Sticker).map_err(conv_err),
-            Tag => from_value(value).map(Self::Tag).map_err(conv_err),
-            Typing => from_value(value).map(Self::Typing).map_err(conv_err),
+            Sticker => from_value(value).map(Event::Sticker).map_err(conv_err),
+            Tag => from_value(value).map(Event::Tag).map_err(conv_err),
+            Typing => from_value(value).map(Event::Typing).map_err(conv_err),
            // TODO
            Custom(_event_type_name) => Err(D::Error::custom("invalid event type")),
            __Nonexhaustive => {
@ -446,49 +456,77 @@ impl<'de> Deserialize<'de> for RoomEvent {
        let event_type = get_field(&value, "type")?;

        match event_type {
-            CallAnswer => from_value(value).map(Self::CallAnswer).map_err(conv_err),
+            CallAnswer => from_value(value)
+                .map(RoomEvent::CallAnswer)
+                .map_err(conv_err),
            CallCandidates => from_value(value)
-                .map(Self::CallCandidates)
+                .map(RoomEvent::CallCandidates)
+                .map_err(conv_err),
+            CallHangup => from_value(value)
+                .map(RoomEvent::CallHangup)
+                .map_err(conv_err),
+            CallInvite => from_value(value)
+                .map(RoomEvent::CallInvite)
+                .map_err(conv_err),
+            RoomAliases => from_value(value)
+                .map(RoomEvent::RoomAliases)
+                .map_err(conv_err),
+            RoomAvatar => from_value(value)
+                .map(RoomEvent::RoomAvatar)
                .map_err(conv_err),
-            CallHangup => from_value(value).map(Self::CallHangup).map_err(conv_err),
-            CallInvite => from_value(value).map(Self::CallInvite).map_err(conv_err),
-            RoomAliases => from_value(value).map(Self::RoomAliases).map_err(conv_err),
-            RoomAvatar => from_value(value).map(Self::RoomAvatar).map_err(conv_err),
            RoomCanonicalAlias => from_value(value)
-                .map(Self::RoomCanonicalAlias)
+                .map(RoomEvent::RoomCanonicalAlias)
+                .map_err(conv_err),
+            RoomCreate => from_value(value)
+                .map(RoomEvent::RoomCreate)
+                .map_err(conv_err),
+            RoomEncrypted => from_value(value)
+                .map(RoomEvent::RoomEncrypted)
                .map_err(conv_err),
-            RoomCreate => from_value(value).map(Self::RoomCreate).map_err(conv_err),
-            RoomEncrypted => from_value(value).map(Self::RoomEncrypted).map_err(conv_err),
            RoomEncryption => from_value(value)
-                .map(Self::RoomEncryption)
+                .map(RoomEvent::RoomEncryption)
                .map_err(conv_err),
            RoomGuestAccess => from_value(value)
-                .map(Self::RoomGuestAccess)
+                .map(RoomEvent::RoomGuestAccess)
                .map_err(conv_err),
            RoomHistoryVisibility => from_value(value)
-                .map(Self::RoomHistoryVisibility)
+                .map(RoomEvent::RoomHistoryVisibility)
+                .map_err(conv_err),
+            RoomJoinRules => from_value(value)
+                .map(RoomEvent::RoomJoinRules)
+                .map_err(conv_err),
+            RoomMember => from_value(value)
+                .map(RoomEvent::RoomMember)
+                .map_err(conv_err),
+            RoomMessage => from_value(value)
+                .map(RoomEvent::RoomMessage)
                .map_err(conv_err),
-            RoomJoinRules => from_value(value).map(Self::RoomJoinRules).map_err(conv_err),
-            RoomMember => from_value(value).map(Self::RoomMember).map_err(conv_err),
-            RoomMessage => from_value(value).map(Self::RoomMessage).map_err(conv_err),
            RoomMessageFeedback => from_value(value)
-                .map(Self::RoomMessageFeedback)
+                .map(RoomEvent::RoomMessageFeedback)
                .map_err(conv_err),
-            RoomName => from_value(value).map(Self::RoomName).map_err(conv_err),
+            RoomName => from_value(value).map(RoomEvent::RoomName).map_err(conv_err),
            RoomPinnedEvents => from_value(value)
-                .map(Self::RoomPinnedEvents)
+                .map(RoomEvent::RoomPinnedEvents)
                .map_err(conv_err),
            RoomPowerLevels => from_value(value)
-                .map(Self::RoomPowerLevels)
+                .map(RoomEvent::RoomPowerLevels)
+                .map_err(conv_err),
+            RoomRedaction => from_value(value)
+                .map(RoomEvent::RoomRedaction)
+                .map_err(conv_err),
+            RoomServerAcl => from_value(value)
+                .map(RoomEvent::RoomServerAcl)
                .map_err(conv_err),
-            RoomRedaction => from_value(value).map(Self::RoomRedaction).map_err(conv_err),
-            RoomServerAcl => from_value(value).map(Self::RoomServerAcl).map_err(conv_err),
            RoomThirdPartyInvite => from_value(value)
-                .map(Self::RoomThirdPartyInvite)
+                .map(RoomEvent::RoomThirdPartyInvite)
                .map_err(conv_err),
-            RoomTombstone => from_value(value).map(Self::RoomTombstone).map_err(conv_err),
-            RoomTopic => from_value(value).map(Self::RoomTopic).map_err(conv_err),
-            Sticker => from_value(value).map(Self::Sticker).map_err(conv_err),
+            RoomTombstone => from_value(value)
+                .map(RoomEvent::RoomTombstone)
+                .map_err(conv_err),
+            RoomTopic => from_value(value)
+                .map(RoomEvent::RoomTopic)
+                .map_err(conv_err),
+            Sticker => from_value(value).map(RoomEvent::Sticker).map_err(conv_err),
            //Custom(_event_type_name) => unimplemented!("todo"),
            _ => Err(D::Error::custom("invalid event type")),
        }
@ -506,36 +544,54 @@ impl<'de> Deserialize<'de> for StateEvent {
        let event_type = get_field(&value, "type")?;

        match event_type {
-            RoomAliases => from_value(value).map(Self::RoomAliases).map_err(conv_err),
-            RoomAvatar => from_value(value).map(Self::RoomAvatar).map_err(conv_err),
-            RoomCanonicalAlias => from_value(value)
-                .map(Self::RoomCanonicalAlias)
+            RoomAliases => from_value(value)
+                .map(StateEvent::RoomAliases)
+                .map_err(conv_err),
+            RoomAvatar => from_value(value)
+                .map(StateEvent::RoomAvatar)
+                .map_err(conv_err),
+            RoomCanonicalAlias => from_value(value)
+                .map(StateEvent::RoomCanonicalAlias)
+                .map_err(conv_err),
+            RoomCreate => from_value(value)
+                .map(StateEvent::RoomCreate)
                .map_err(conv_err),
-            RoomCreate => from_value(value).map(Self::RoomCreate).map_err(conv_err),
            RoomEncryption => from_value(value)
-                .map(Self::RoomEncryption)
+                .map(StateEvent::RoomEncryption)
                .map_err(conv_err),
            RoomGuestAccess => from_value(value)
-                .map(Self::RoomGuestAccess)
+                .map(StateEvent::RoomGuestAccess)
                .map_err(conv_err),
            RoomHistoryVisibility => from_value(value)
-                .map(Self::RoomHistoryVisibility)
+                .map(StateEvent::RoomHistoryVisibility)
+                .map_err(conv_err),
+            RoomJoinRules => from_value(value)
+                .map(StateEvent::RoomJoinRules)
+                .map_err(conv_err),
+            RoomMember => from_value(value)
+                .map(StateEvent::RoomMember)
+                .map_err(conv_err),
+            RoomName => from_value(value)
+                .map(StateEvent::RoomName)
                .map_err(conv_err),
-            RoomJoinRules => from_value(value).map(Self::RoomJoinRules).map_err(conv_err),
-            RoomMember => from_value(value).map(Self::RoomMember).map_err(conv_err),
-            RoomName => from_value(value).map(Self::RoomName).map_err(conv_err),
            RoomPinnedEvents => from_value(value)
-                .map(Self::RoomPinnedEvents)
+                .map(StateEvent::RoomPinnedEvents)
                .map_err(conv_err),
            RoomPowerLevels => from_value(value)
-                .map(Self::RoomPowerLevels)
+                .map(StateEvent::RoomPowerLevels)
+                .map_err(conv_err),
+            RoomServerAcl => from_value(value)
+                .map(StateEvent::RoomServerAcl)
                .map_err(conv_err),
-            RoomServerAcl => from_value(value).map(Self::RoomServerAcl).map_err(conv_err),
            RoomThirdPartyInvite => from_value(value)
-                .map(Self::RoomThirdPartyInvite)
+                .map(StateEvent::RoomThirdPartyInvite)
+                .map_err(conv_err),
+            RoomTombstone => from_value(value)
+                .map(StateEvent::RoomTombstone)
+                .map_err(conv_err),
+            RoomTopic => from_value(value)
+                .map(StateEvent::RoomTopic)
                .map_err(conv_err),
-            RoomTombstone => from_value(value).map(Self::RoomTombstone).map_err(conv_err),
-            RoomTopic => from_value(value).map(Self::RoomTopic).map_err(conv_err),
            //Custom(_event_type_name) => unimplemented!("todo"),
            _ => Err(D::Error::custom("invalid event type")),
        }
--- a/src/collections/raw/only.rs
+++ b/src/collections/raw/only.rs
@ -154,42 +154,42 @@ impl<'de> Deserialize<'de> for Event {
        let event_type = get_field(&value, "type")?;

        match event_type {
-            Direct => from_value(value).map(Self::Direct).map_err(conv_err),
-            Dummy => from_value(value).map(Self::Dummy).map_err(conv_err),
+            Direct => from_value(value).map(Event::Direct).map_err(conv_err),
+            Dummy => from_value(value).map(Event::Dummy).map_err(conv_err),
            ForwardedRoomKey => from_value(value)
-                .map(Self::ForwardedRoomKey)
+                .map(Event::ForwardedRoomKey)
                .map_err(conv_err),
-            FullyRead => from_value(value).map(Self::FullyRead).map_err(conv_err),
+            FullyRead => from_value(value).map(Event::FullyRead).map_err(conv_err),
            KeyVerificationAccept => from_value(value)
-                .map(Self::KeyVerificationAccept)
+                .map(Event::KeyVerificationAccept)
                .map_err(conv_err),
            KeyVerificationCancel => from_value(value)
-                .map(Self::KeyVerificationCancel)
+                .map(Event::KeyVerificationCancel)
                .map_err(conv_err),
            KeyVerificationKey => from_value(value)
-                .map(Self::KeyVerificationKey)
+                .map(Event::KeyVerificationKey)
                .map_err(conv_err),
            KeyVerificationMac => from_value(value)
-                .map(Self::KeyVerificationMac)
+                .map(Event::KeyVerificationMac)
                .map_err(conv_err),
            KeyVerificationRequest => from_value(value)
-                .map(Self::KeyVerificationRequest)
+                .map(Event::KeyVerificationRequest)
                .map_err(conv_err),
            KeyVerificationStart => from_value(value)
-                .map(Self::KeyVerificationStart)
+                .map(Event::KeyVerificationStart)
                .map_err(conv_err),
            IgnoredUserList => from_value(value)
-                .map(Self::IgnoredUserList)
+                .map(Event::IgnoredUserList)
                .map_err(conv_err),
-            Presence => from_value(value).map(Self::Presence).map_err(conv_err),
-            PushRules => from_value(value).map(Self::PushRules).map_err(conv_err),
-            RoomKey => from_value(value).map(Self::RoomKey).map_err(conv_err),
+            Presence => from_value(value).map(Event::Presence).map_err(conv_err),
+            PushRules => from_value(value).map(Event::PushRules).map_err(conv_err),
+            RoomKey => from_value(value).map(Event::RoomKey).map_err(conv_err),
            RoomKeyRequest => from_value(value)
-                .map(Self::RoomKeyRequest)
+                .map(Event::RoomKeyRequest)
                .map_err(conv_err),
-            Receipt => from_value(value).map(Self::Receipt).map_err(conv_err),
-            Tag => from_value(value).map(Self::Tag).map_err(conv_err),
-            Typing => from_value(value).map(Self::Typing).map_err(conv_err),
+            Receipt => from_value(value).map(Event::Receipt).map_err(conv_err),
+            Tag => from_value(value).map(Event::Tag).map_err(conv_err),
+            Typing => from_value(value).map(Event::Typing).map_err(conv_err),
            //Custom(_event_type_name) => unimplemented!("todo"),
            _ => Err(D::Error::custom("invalid event type")),
        }
@ -207,19 +207,31 @@ impl<'de> Deserialize<'de> for RoomEvent {
        let event_type = get_field(&value, "type")?;

        match event_type {
-            CallAnswer => from_value(value).map(Self::CallAnswer).map_err(conv_err),
+            CallAnswer => from_value(value)
+                .map(RoomEvent::CallAnswer)
+                .map_err(conv_err),
            CallCandidates => from_value(value)
-                .map(Self::CallCandidates)
+                .map(RoomEvent::CallCandidates)
+                .map_err(conv_err),
+            CallHangup => from_value(value)
+                .map(RoomEvent::CallHangup)
+                .map_err(conv_err),
+            CallInvite => from_value(value)
+                .map(RoomEvent::CallInvite)
+                .map_err(conv_err),
+            RoomEncrypted => from_value(value)
+                .map(RoomEvent::RoomEncrypted)
+                .map_err(conv_err),
+            RoomMessage => from_value(value)
+                .map(RoomEvent::RoomMessage)
                .map_err(conv_err),
-            CallHangup => from_value(value).map(Self::CallHangup).map_err(conv_err),
-            CallInvite => from_value(value).map(Self::CallInvite).map_err(conv_err),
-            RoomEncrypted => from_value(value).map(Self::RoomEncrypted).map_err(conv_err),
-            RoomMessage => from_value(value).map(Self::RoomMessage).map_err(conv_err),
            RoomMessageFeedback => from_value(value)
-                .map(Self::RoomMessageFeedback)
+                .map(RoomEvent::RoomMessageFeedback)
                .map_err(conv_err),
-            RoomRedaction => from_value(value).map(Self::RoomRedaction).map_err(conv_err),
-            Sticker => from_value(value).map(Self::Sticker).map_err(conv_err),
+            RoomRedaction => from_value(value)
+                .map(RoomEvent::RoomRedaction)
+                .map_err(conv_err),
+            Sticker => from_value(value).map(RoomEvent::Sticker).map_err(conv_err),
            //Custom(_event_type_name) => unimplemented!("todo"),
            _ => Err(D::Error::custom("invalid event type")),
        }
--- a/src/key/verification/start.rs
+++ b/src/key/verification/start.rs
@ -1,7 +1,7 @@
 //! Types for the *m.key.verification.start* event.

 use ruma_identifiers::DeviceId;
-use serde::{de::Error, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
+use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::{from_value, Value};

 use super::{
@ -157,6 +157,8 @@ pub(crate) mod raw {
        where
            D: Deserializer<'de>,
        {
+            use serde::de::Error as _;
+
            let value: Value = Deserialize::deserialize(deserializer)?;

            let method_value = match value.get("method") {
--- a/src/lib.rs
+++ b/src/lib.rs
@ -128,9 +128,7 @@ use serde::{
 };
 use serde_json::Value;

-pub use custom::CustomEvent;
-pub use custom_room::CustomRoomEvent;
-pub use custom_state::CustomStateEvent;
+pub use self::{custom::CustomEvent, custom_room::CustomRoomEvent, custom_state::CustomStateEvent};

 #[macro_use]
 mod macros;
--- a/src/room/encrypted.rs
+++ b/src/room/encrypted.rs
@ -2,7 +2,7 @@

 use js_int::UInt;
 use ruma_identifiers::{DeviceId, EventId, RoomId, UserId};
-use serde::{de::Error, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
+use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::{from_value, Value};

 use crate::{Algorithm, Event, EventType, FromRaw};
@ -70,8 +70,10 @@ impl FromRaw for EncryptedEventContent {
        use raw::EncryptedEventContent::*;

        match raw {
-            OlmV1Curve25519AesSha2(content) => Self::OlmV1Curve25519AesSha2(content),
-            MegolmV1AesSha2(content) => Self::MegolmV1AesSha2(content),
+            OlmV1Curve25519AesSha2(content) => {
+                EncryptedEventContent::OlmV1Curve25519AesSha2(content)
+            }
+            MegolmV1AesSha2(content) => EncryptedEventContent::MegolmV1AesSha2(content),
            __Nonexhaustive => {
                unreachable!("__Nonexhaustive variant should be impossible to obtain.")
            }
@ -185,6 +187,8 @@ pub(crate) mod raw {
        where
            D: Deserializer<'de>,
        {
+            use serde::de::Error as _;
+
            let value: Value = Deserialize::deserialize(deserializer)?;

            let method_value = match value.get("algorithm") {
--- a/src/room/message.rs
+++ b/src/room/message.rs
@ -2,11 +2,7 @@

 use js_int::UInt;
 use ruma_identifiers::{EventId, RoomId, UserId};
-use serde::{
-    de::Error as _,
-    ser::{Error as _, SerializeStruct},
-    Deserialize, Deserializer, Serialize, Serializer,
-};
+use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::{from_value, Value};

 use super::{EncryptedFile, ImageInfo, ThumbnailInfo};
@ -96,15 +92,15 @@ impl FromRaw for MessageEventContent {
        use raw::MessageEventContent::*;

        match raw {
-            Audio(content) => Self::Audio(content),
-            Emote(content) => Self::Emote(content),
-            File(content) => Self::File(content),
-            Image(content) => Self::Image(content),
-            Location(content) => Self::Location(content),
-            Notice(content) => Self::Notice(content),
-            ServerNotice(content) => Self::ServerNotice(content),
-            Text(content) => Self::Text(content),
-            Video(content) => Self::Video(content),
+            Audio(content) => MessageEventContent::Audio(content),
+            Emote(content) => MessageEventContent::Emote(content),
+            File(content) => MessageEventContent::File(content),
+            Image(content) => MessageEventContent::Image(content),
+            Location(content) => MessageEventContent::Location(content),
+            Notice(content) => MessageEventContent::Notice(content),
+            ServerNotice(content) => MessageEventContent::ServerNotice(content),
+            Text(content) => MessageEventContent::Text(content),
+            Video(content) => MessageEventContent::Video(content),
            __Nonexhaustive => {
                unreachable!("It should be impossible to obtain a __Nonexhaustive variant.")
            }
@ -155,6 +151,8 @@ impl Serialize for MessageEventContent {
    where
        S: Serializer,
    {
+        use serde::ser::Error as _;
+
        match *self {
            MessageEventContent::Audio(ref content) => content.serialize(serializer),
            MessageEventContent::Emote(ref content) => content.serialize(serializer),
@ -240,6 +238,8 @@ pub(crate) mod raw {
        where
            D: Deserializer<'de>,
        {
+            use serde::de::Error as _;
+
            let value: Value = Deserialize::deserialize(deserializer)?;

            let message_type_value = match value.get("msgtype") {
--- a/src/stripped.rs
+++ b/src/stripped.rs
@ -126,18 +126,24 @@ impl TryFromRaw for StrippedState {
        use raw::StrippedState::*;

        match raw {
-            RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c),
-            RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c),
-            RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c),
-            RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c),
-            RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c),
-            RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c),
-            RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c),
-            RoomMember(c) => conv(RoomMember, Self::RoomMember, c),
-            RoomName(c) => conv(RoomName, Self::RoomName, c),
-            RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c),
-            RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c),
-            RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c),
+            RoomAliases(c) => conv(RoomAliases, StrippedState::RoomAliases, c),
+            RoomAvatar(c) => conv(RoomAvatar, StrippedState::RoomAvatar, c),
+            RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, StrippedState::RoomCanonicalAlias, c),
+            RoomCreate(c) => conv(RoomCreate, StrippedState::RoomCreate, c),
+            RoomGuestAccess(c) => conv(RoomGuestAccess, StrippedState::RoomGuestAccess, c),
+            RoomHistoryVisibility(c) => conv(
+                RoomHistoryVisibility,
+                StrippedState::RoomHistoryVisibility,
+                c,
+            ),
+            RoomJoinRules(c) => conv(RoomJoinRules, StrippedState::RoomJoinRules, c),
+            RoomMember(c) => conv(RoomMember, StrippedState::RoomMember, c),
+            RoomName(c) => conv(RoomName, StrippedState::RoomName, c),
+            RoomPowerLevels(c) => conv(RoomPowerLevels, StrippedState::RoomPowerLevels, c),
+            RoomThirdPartyInvite(c) => {
+                conv(RoomThirdPartyInvite, StrippedState::RoomThirdPartyInvite, c)
+            }
+            RoomTopic(c) => conv(RoomTopic, StrippedState::RoomTopic, c),
        }
    }
 }
@ -210,6 +216,7 @@ where

 mod raw {
    use serde::{Deserialize, Deserializer};
+    use serde_json::Value;

    use super::StrippedStateContent;
    use crate::room::{
@ -304,44 +311,56 @@ mod raw {
        where
            D: Deserializer<'de>,
        {
-            use crate::EventType::*;
+            use crate::{
+                util::{get_field, serde_json_error_to_generic_de_error as conv_err},
+                EventType::*,
+            };
            use serde::de::Error as _;
-            use serde_json::{from_value, Value};
-
-            let conv_err = |error: serde_json::Error| D::Error::custom(error.to_string());
+            use serde_json::from_value;

            // TODO: Optimize
            let value = Value::deserialize(deserializer)?;
+            let event_type = get_field(&value, "type")?;

-            let event_type = from_value(
-                value
-                    .get("type")
-                    .cloned()
-                    .ok_or_else(|| D::Error::missing_field("type"))?,
-            )
-            .map_err(conv_err)?;
-
-            Ok(match event_type {
-                RoomAliases => StrippedState::RoomAliases(from_value(value).map_err(conv_err)?),
-                RoomAvatar => Self::RoomAvatar(from_value(value).map_err(conv_err)?),
-                RoomCanonicalAlias => {
-                    Self::RoomCanonicalAlias(from_value(value).map_err(conv_err)?)
-                }
-                RoomCreate => Self::RoomCreate(from_value(value).map_err(conv_err)?),
-                RoomGuestAccess => Self::RoomGuestAccess(from_value(value).map_err(conv_err)?),
-                RoomHistoryVisibility => {
-                    Self::RoomHistoryVisibility(from_value(value).map_err(conv_err)?)
-                }
-                RoomJoinRules => Self::RoomJoinRules(from_value(value).map_err(conv_err)?),
-                RoomMember => Self::RoomMember(from_value(value).map_err(conv_err)?),
-                RoomName => Self::RoomName(from_value(value).map_err(conv_err)?),
-                RoomPowerLevels => Self::RoomPowerLevels(from_value(value).map_err(conv_err)?),
-                RoomThirdPartyInvite => {
-                    Self::RoomThirdPartyInvite(from_value(value).map_err(conv_err)?)
-                }
-                RoomTopic => Self::RoomTopic(from_value(value).map_err(conv_err)?),
-                _ => return Err(D::Error::custom("not a state event")),
-            })
+            match event_type {
+                RoomAliases => from_value(value)
+                    .map(StrippedState::RoomAliases)
+                    .map_err(conv_err),
+                RoomAvatar => from_value(value)
+                    .map(StrippedState::RoomAvatar)
+                    .map_err(conv_err),
+                RoomCanonicalAlias => from_value(value)
+                    .map(StrippedState::RoomCanonicalAlias)
+                    .map_err(conv_err),
+                RoomCreate => from_value(value)
+                    .map(StrippedState::RoomCreate)
+                    .map_err(conv_err),
+                RoomGuestAccess => from_value(value)
+                    .map(StrippedState::RoomGuestAccess)
+                    .map_err(conv_err),
+                RoomHistoryVisibility => from_value(value)
+                    .map(StrippedState::RoomHistoryVisibility)
+                    .map_err(conv_err),
+                RoomJoinRules => from_value(value)
+                    .map(StrippedState::RoomJoinRules)
+                    .map_err(conv_err),
+                RoomMember => from_value(value)
+                    .map(StrippedState::RoomMember)
+                    .map_err(conv_err),
+                RoomName => from_value(value)
+                    .map(StrippedState::RoomName)
+                    .map_err(conv_err),
+                RoomPowerLevels => from_value(value)
+                    .map(StrippedState::RoomPowerLevels)
+                    .map_err(conv_err),
+                RoomThirdPartyInvite => from_value(value)
+                    .map(StrippedState::RoomThirdPartyInvite)
+                    .map_err(conv_err),
+                RoomTopic => from_value(value)
+                    .map(StrippedState::RoomTopic)
+                    .map_err(conv_err),
+                _ => Err(D::Error::custom("not a state event")),
+            }
        }
    }
 }