events: Add 'Original' prefix to unredacted types with a redacted form

crates/ruma-client-api/src/context/get_context.rs

@@ -8,7 +8,7 @@ pub mod v3 {
     use js_int::{uint, UInt};
     use ruma_common::{
         api::ruma_api,
-        events::{AnyRoomEvent, AnyStateEvent},
+        events::{AnyOriginalStateEvent, AnyRoomEvent},
         serde::Raw,
         EventId, RoomId,
     };
@@ -79,7 +79,7 @@ pub mod v3 {
 
             /// The state of the room at the last event returned.
             #[serde(default, skip_serializing_if = "Vec::is_empty")]
-            pub state: Vec<Raw<AnyStateEvent>>,
+            pub state: Vec<Raw<AnyOriginalStateEvent>>,
         }
 
         error: crate::Error

crates/ruma-client-api/src/membership/get_member_events.rs

@@ -7,7 +7,7 @@ pub mod v3 {
 
     use ruma_common::{
         api::ruma_api,
-        events::room::member::RoomMemberEvent,
+        events::room::member::OriginalRoomMemberEvent,
         serde::{Raw, StringEnum},
         RoomId,
     };
@@ -58,7 +58,7 @@ pub mod v3 {
 
         response: {
             /// A list of member events.
-            pub chunk: Vec<Raw<RoomMemberEvent>>,
+            pub chunk: Vec<Raw<OriginalRoomMemberEvent>>,
         }
 
         error: crate::Error
@@ -73,7 +73,7 @@ pub mod v3 {
 
     impl Response {
         /// Creates a new `Response` with the given member event chunk.
-        pub fn new(chunk: Vec<Raw<RoomMemberEvent>>) -> Self {
+        pub fn new(chunk: Vec<Raw<OriginalRoomMemberEvent>>) -> Self {
             Self { chunk }
         }
     }

crates/ruma-client-api/src/message/get_message_events.rs

@@ -8,7 +8,7 @@ pub mod v3 {
     use js_int::{uint, UInt};
     use ruma_common::{
         api::ruma_api,
-        events::{AnyRoomEvent, AnyStateEvent},
+        events::{AnyOriginalStateEvent, AnyRoomEvent},
         serde::Raw,
         RoomId,
     };
@@ -96,7 +96,7 @@ pub mod v3 {
 
             /// A list of state events relevant to showing the `chunk`.
             #[serde(default, skip_serializing_if = "Vec::is_empty")]
-            pub state: Vec<Raw<AnyStateEvent>>,
+            pub state: Vec<Raw<AnyOriginalStateEvent>>,
         }
 
         error: crate::Error

crates/ruma-client-api/src/search/search_events.rs

@@ -10,7 +10,7 @@ pub mod v3 {
     use js_int::{uint, UInt};
     use ruma_common::{
         api::ruma_api,
-        events::{AnyRoomEvent, AnyStateEvent},
+        events::{AnyOriginalStateEvent, AnyRoomEvent},
         serde::{Incoming, Raw, StringEnum},
         EventId, MxcUri, RoomId, UserId,
     };
@@ -385,7 +385,7 @@ pub mod v3 {
         ///
         /// This is included if the request had the `include_state` key set with a value of `true`.
         #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
-        pub state: BTreeMap<Box<RoomId>, Vec<Raw<AnyStateEvent>>>,
+        pub state: BTreeMap<Box<RoomId>, Vec<Raw<AnyOriginalStateEvent>>>,
 
         /// List of words which should be highlighted, useful for stemming which may
         /// change the query terms.

crates/ruma-client-api/src/state/get_state_events.rs

@@ -5,7 +5,7 @@ pub mod v3 {
     //!
     //! [spec]: https://spec.matrix.org/v1.2/client-server-api/#get_matrixclientv3roomsroomidstate
 
-    use ruma_common::{api::ruma_api, events::AnyStateEvent, serde::Raw, RoomId};
+    use ruma_common::{api::ruma_api, events::AnyOriginalStateEvent, serde::Raw, RoomId};
 
     ruma_api! {
         metadata: {
@@ -32,7 +32,7 @@ pub mod v3 {
             /// If the user has left the room then this will be the state of the room when they left as
             /// a list of events.
             #[ruma_api(body)]
-            pub room_state: Vec<Raw<AnyStateEvent>>,
+            pub room_state: Vec<Raw<AnyOriginalStateEvent>>,
         }
 
         error: crate::Error
@@ -47,7 +47,7 @@ pub mod v3 {
 
     impl Response {
         /// Creates a new `Response` with the given room state.
-        pub fn new(room_state: Vec<Raw<AnyStateEvent>>) -> Self {
+        pub fn new(room_state: Vec<Raw<AnyOriginalStateEvent>>) -> Self {
             Self { room_state }
         }
     }

crates/ruma-client-api/src/sync/sync_events.rs

@@ -11,9 +11,9 @@ pub mod v3 {
     use ruma_common::{
         api::ruma_api,
         events::{
-            presence::PresenceEvent, AnyGlobalAccountDataEvent, AnyRoomAccountDataEvent,
+            presence::PresenceEvent, AnyGlobalAccountDataEvent, AnyOriginalSyncStateEvent,
-            AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnySyncRoomEvent, AnySyncStateEvent,
+            AnyRoomAccountDataEvent, AnyStrippedStateEvent, AnySyncEphemeralRoomEvent,
-            AnyToDeviceEvent,
+            AnySyncRoomEvent, AnyToDeviceEvent,
         },
         presence::PresenceState,
         serde::{Incoming, Raw},
@@ -384,7 +384,7 @@ pub mod v3 {
     pub struct State {
         /// A list of state events.
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
-        pub events: Vec<Raw<AnySyncStateEvent>>,
+        pub events: Vec<Raw<AnyOriginalSyncStateEvent>>,
     }
 
     impl State {

crates/ruma-common/benches/event_deserialize.rs

@@ -11,7 +11,8 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use ruma_common::{
     events::{
-        room::power_levels::RoomPowerLevelsEventContent, AnyRoomEvent, AnyStateEvent, StateEvent,
+        room::power_levels::RoomPowerLevelsEventContent, AnyOriginalStateEvent, AnyRoomEvent,
+        OriginalStateEvent,
     },
     serde::Raw,
 };
@@ -65,9 +66,9 @@ fn deserialize_any_room_event(c: &mut Criterion) {
 fn deserialize_any_state_event(c: &mut Criterion) {
     let json_data = power_levels();
 
-    c.bench_function("deserialize to `AnyStateEvent`", |b| {
+    c.bench_function("deserialize to `AnyOriginalStateEvent`", |b| {
         b.iter(|| {
-            let _ = serde_json::from_value::<AnyStateEvent>(json_data.clone()).unwrap();
+            let _ = serde_json::from_value::<AnyOriginalStateEvent>(json_data.clone()).unwrap();
         })
     });
 }
@@ -76,9 +77,9 @@ fn deserialize_any_state_event(c: &mut Criterion) {
 fn deserialize_specific_event(c: &mut Criterion) {
     let json_data = power_levels();
 
-    c.bench_function("deserialize to `StateEvent<PowerLevelsEventContent>`", |b| {
+    c.bench_function("deserialize to `OriginalStateEvent<PowerLevelsEventContent>`", |b| {
         b.iter(|| {
-            let _ = serde_json::from_value::<StateEvent<RoomPowerLevelsEventContent>>(
+            let _ = serde_json::from_value::<OriginalStateEvent<RoomPowerLevelsEventContent>>(
                 json_data.clone(),
             )
             .unwrap();

crates/ruma-common/src/events.rs

@@ -38,10 +38,10 @@
 //! `ruma::api::client::state::send_state_event`'s `Request`.
 //!
 //! As a more advanced example we create a reaction message event. For this event we will use a
-//! [`SyncMessageLikeEvent`] struct but any [`MessageLikeEvent`] struct would work.
+//! [`OriginalSyncMessageLikeEvent`] struct but any [`OriginalMessageLikeEvent`] struct would work.
 //!
 //! ```rust
-//! use ruma_common::events::{macros::EventContent, SyncMessageLikeEvent};
+//! use ruma_common::events::{macros::EventContent, OriginalSyncMessageLikeEvent};
 //! use ruma_common::EventId;
 //! use serde::{Deserialize, Serialize};
 //!
@@ -90,8 +90,8 @@
 //! // The downside of this event is we cannot use it with event enums,
 //! // but could be deserialized from a `Raw<_>` that has failed to deserialize.
 //! matches::assert_matches!(
-//!     serde_json::from_value::<SyncMessageLikeEvent<ReactionEventContent>>(json),
+//!     serde_json::from_value::<OriginalSyncMessageLikeEvent<ReactionEventContent>>(json),
-//!     Ok(SyncMessageLikeEvent {
+//!     Ok(OriginalSyncMessageLikeEvent {
 //!         content: ReactionEventContent {
 //!             relates_to: RelatesTo::Annotation { key, .. },
 //!         },
@@ -102,7 +102,7 @@
 
 use serde::{de::IgnoredAny, Deserialize, Serializer};
 
-use self::room::redaction::SyncRoomRedactionEvent;
+use self::room::redaction::OriginalSyncRoomRedactionEvent;
 use crate::{EventEncryptionAlgorithm, RoomVersionId};
 
 // Needs to be public for trybuild tests
@@ -180,7 +180,11 @@ pub trait Redact {
     ///
     /// A small number of events have room-version specific redaction behavior, so a version has to
     /// be specified.
-    fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self::Redacted;
+    fn redact(
+        self,
+        redaction: OriginalSyncRoomRedactionEvent,
+        version: &RoomVersionId,
+    ) -> Self::Redacted;
 }
 
 /// Trait to define the behavior of redact an event's content object.

crates/ruma-common/src/events/content.rs

@@ -39,9 +39,9 @@ where
 /// The base trait that all redacted event content types implement.
 ///
 /// This trait's associated functions and methods should not be used to build
-/// redacted events, prefer the `redact` method on `AnyStateEvent` and
+/// redacted events, prefer the `redact` method on `AnyOriginalStateEvent` and
-/// `AnyMessageLikeEvent` and their "sync" and "stripped" counterparts. The
+/// `AnyOriginalMessageLikeEvent` and their "sync" and "stripped" counterparts.
-/// `RedactedEventContent` trait is an implementation detail, ruma makes no
+/// The `RedactedEventContent` trait is an implementation detail, ruma makes no
 /// API guarantees.
 pub trait RedactedEventContent: EventContent {
     /// Constructs the redacted event content.

crates/ruma-common/src/events/enums.rs

@@ -4,7 +4,7 @@ use serde_json::value::RawValue as RawJsonValue;
 
 use super::{
     key,
-    room::{encrypted, redaction::SyncRoomRedactionEvent},
+    room::{encrypted, redaction::OriginalSyncRoomRedactionEvent},
     Redact, UnsignedDeHelper,
 };
 use crate::{
@@ -129,8 +129,8 @@ macro_rules! room_ev_accessor {
             #[doc = concat!("Returns this event's `", stringify!($field), "` field.")]
             pub fn $field(&self) -> $ty {
                 match self {
-                    Self::MessageLike(ev) => ev.$field(),
+                    Self::OriginalMessageLike(ev) => ev.$field(),
-                    Self::State(ev) => ev.$field(),
+                    Self::OriginalState(ev) => ev.$field(),
                     Self::RedactedMessageLike(ev) => ev.$field(),
                     Self::RedactedState(ev) => ev.$field(),
                 }
@@ -143,11 +143,11 @@ macro_rules! room_ev_accessor {
 #[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
 #[derive(Clone, Debug, EventEnumFromEvent)]
 pub enum AnyRoomEvent {
-    /// Any message-like event.
+    /// Any message-like event (unredacted).
-    MessageLike(AnyMessageLikeEvent),
+    OriginalMessageLike(AnyOriginalMessageLikeEvent),
 
-    /// Any state event.
+    /// Any state event (unredacted).
-    State(AnyStateEvent),
+    OriginalState(AnyOriginalStateEvent),
 
     /// Any message-like event that has been redacted.
     RedactedMessageLike(AnyRedactedMessageLikeEvent),
@@ -169,11 +169,11 @@ impl AnyRoomEvent {
 #[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
 #[derive(Clone, Debug, EventEnumFromEvent)]
 pub enum AnySyncRoomEvent {
-    /// Any sync message-like event.
+    /// Any sync message-like event (unredacted).
-    MessageLike(AnySyncMessageLikeEvent),
+    OriginalMessageLike(AnyOriginalSyncMessageLikeEvent),
 
-    /// Any sync state event.
+    /// Any sync state event (unredacted).
-    State(AnySyncStateEvent),
+    OriginalState(AnyOriginalSyncStateEvent),
 
     /// Any sync message-like event that has been redacted.
     RedactedMessageLike(AnyRedactedSyncMessageLikeEvent),
@@ -190,8 +190,10 @@ impl AnySyncRoomEvent {
     /// Converts `self` to an `AnyRoomEvent` by adding the given a room ID.
     pub fn into_full_event(self, room_id: Box<RoomId>) -> AnyRoomEvent {
         match self {
-            Self::MessageLike(ev) => AnyRoomEvent::MessageLike(ev.into_full_event(room_id)),
+            Self::OriginalMessageLike(ev) => {
-            Self::State(ev) => AnyRoomEvent::State(ev.into_full_event(room_id)),
+                AnyRoomEvent::OriginalMessageLike(ev.into_full_event(room_id))
+            }
+            Self::OriginalState(ev) => AnyRoomEvent::OriginalState(ev.into_full_event(room_id)),
             Self::RedactedMessageLike(ev) => {
                 AnyRoomEvent::RedactedMessageLike(ev.into_full_event(room_id))
             }
@@ -220,14 +222,14 @@ impl<'de> Deserialize<'de> for AnyRoomEvent {
                 Some(unsigned) if unsigned.redacted_because.is_some() => {
                     AnyRoomEvent::RedactedState(from_raw_json_value(&json)?)
                 }
-                _ => AnyRoomEvent::State(from_raw_json_value(&json)?),
+                _ => AnyRoomEvent::OriginalState(from_raw_json_value(&json)?),
             })
         } else {
             Ok(match unsigned {
                 Some(unsigned) if unsigned.redacted_because.is_some() => {
                     AnyRoomEvent::RedactedMessageLike(from_raw_json_value(&json)?)
                 }
-                _ => AnyRoomEvent::MessageLike(from_raw_json_value(&json)?),
+                _ => AnyRoomEvent::OriginalMessageLike(from_raw_json_value(&json)?),
             })
         }
     }
@@ -246,14 +248,14 @@ impl<'de> Deserialize<'de> for AnySyncRoomEvent {
                 Some(unsigned) if unsigned.redacted_because.is_some() => {
                     AnySyncRoomEvent::RedactedState(from_raw_json_value(&json)?)
                 }
-                _ => AnySyncRoomEvent::State(from_raw_json_value(&json)?),
+                _ => AnySyncRoomEvent::OriginalState(from_raw_json_value(&json)?),
             })
         } else {
             Ok(match unsigned {
                 Some(unsigned) if unsigned.redacted_because.is_some() => {
                     AnySyncRoomEvent::RedactedMessageLike(from_raw_json_value(&json)?)
                 }
-                _ => AnySyncRoomEvent::MessageLike(from_raw_json_value(&json)?),
+                _ => AnySyncRoomEvent::OriginalMessageLike(from_raw_json_value(&json)?),
             })
         }
     }
@@ -276,12 +278,18 @@ impl Redact for AnyRoomEvent {
     /// Redacts `self`, referencing the given event in `unsigned.redacted_because`.
     ///
     /// Does nothing for events that are already redacted.
-    fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self::Redacted {
+    fn redact(
+        self,
+        redaction: OriginalSyncRoomRedactionEvent,
+        version: &RoomVersionId,
+    ) -> Self::Redacted {
         match self {
-            Self::MessageLike(ev) => Self::Redacted::MessageLike(ev.redact(redaction, version)),
+            Self::OriginalMessageLike(ev) => {
-            Self::State(ev) => Self::Redacted::State(ev.redact(redaction, version)),
+                AnyRedactedRoomEvent::MessageLike(ev.redact(redaction, version))
-            Self::RedactedMessageLike(ev) => Self::Redacted::MessageLike(ev),
+            }
-            Self::RedactedState(ev) => Self::Redacted::State(ev),
+            Self::OriginalState(ev) => AnyRedactedRoomEvent::State(ev.redact(redaction, version)),
+            Self::RedactedMessageLike(ev) => AnyRedactedRoomEvent::MessageLike(ev),
+            Self::RedactedState(ev) => AnyRedactedRoomEvent::State(ev),
         }
     }
 }
@@ -312,12 +320,20 @@ impl Redact for AnySyncRoomEvent {
     /// Redacts `self`, referencing the given event in `unsigned.redacted_because`.
     ///
     /// Does nothing for events that are already redacted.
-    fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self::Redacted {
+    fn redact(
+        self,
+        redaction: OriginalSyncRoomRedactionEvent,
+        version: &RoomVersionId,
+    ) -> AnyRedactedSyncRoomEvent {
         match self {
-            Self::MessageLike(ev) => Self::Redacted::MessageLike(ev.redact(redaction, version)),
+            Self::OriginalMessageLike(ev) => {
-            Self::State(ev) => Self::Redacted::State(ev.redact(redaction, version)),
+                AnyRedactedSyncRoomEvent::MessageLike(ev.redact(redaction, version))
-            Self::RedactedMessageLike(ev) => Self::Redacted::MessageLike(ev),
+            }
-            Self::RedactedState(ev) => Self::Redacted::State(ev),
+            Self::OriginalState(ev) => {
+                AnyRedactedSyncRoomEvent::State(ev.redact(redaction, version))
+            }
+            Self::RedactedMessageLike(ev) => AnyRedactedSyncRoomEvent::MessageLike(ev),
+            Self::RedactedState(ev) => AnyRedactedSyncRoomEvent::State(ev),
         }
     }
 }

crates/ruma-common/src/events/kinds.rs

@@ -44,10 +44,10 @@ pub struct SyncEphemeralRoomEvent<C: EphemeralRoomEventContent> {
 
 /// A message-like event.
 ///
-/// `MessageLikeEvent` implements the comparison traits using only the `event_id` field, a sorted
+/// `OriginalMessageLikeEvent` implements the comparison traits using only the `event_id` field, a
-/// list would be sorted lexicographically based on the event's `EventId`.
+/// sorted list would be sorted lexicographically based on the event's `EventId`.
 #[derive(Clone, Debug, Event)]
-pub struct MessageLikeEvent<C: MessageLikeEventContent> {
+pub struct OriginalMessageLikeEvent<C: MessageLikeEventContent> {
     /// Data specific to the event type.
     pub content: C,
 
@@ -69,10 +69,10 @@ pub struct MessageLikeEvent<C: MessageLikeEventContent> {
 
 /// A message-like event without a `room_id`.
 ///
-/// `SyncMessageLikeEvent` implements the comparison traits using only the `event_id` field, a
+/// `OriginalSyncMessageLikeEvent` implements the comparison traits using only the `event_id` field,
-/// sorted list would be sorted lexicographically based on the event's `EventId`.
+/// a sorted list would be sorted lexicographically based on the event's `EventId`.
 #[derive(Clone, Debug, Event)]
-pub struct SyncMessageLikeEvent<C: MessageLikeEventContent> {
+pub struct OriginalSyncMessageLikeEvent<C: MessageLikeEventContent> {
     /// Data specific to the event type.
     pub content: C,
 
@@ -138,10 +138,10 @@ pub struct RedactedSyncMessageLikeEvent<C: RedactedMessageLikeEventContent> {
 
 /// A state event.
 ///
-/// `StateEvent` implements the comparison traits using only the `event_id` field, a sorted list
+/// `OriginalStateEvent` implements the comparison traits using only the `event_id` field, a sorted
-/// would be sorted lexicographically based on the event's `EventId`.
+/// list would be sorted lexicographically based on the event's `EventId`.
 #[derive(Clone, Debug, Event)]
-pub struct StateEvent<C: StateEventContent> {
+pub struct OriginalStateEvent<C: StateEventContent> {
     /// Data specific to the event type.
     pub content: C,
 
@@ -169,10 +169,10 @@ pub struct StateEvent<C: StateEventContent> {
 
 /// A state event without a `room_id`.
 ///
-/// `SyncStateEvent` implements the comparison traits using only the `event_id` field, a sorted list
+/// `OriginalSyncStateEvent` implements the comparison traits using only the `event_id` field, a
-/// would be sorted lexicographically based on the event's `EventId`.
+/// sorted list would be sorted lexicographically based on the event's `EventId`.
 #[derive(Clone, Debug, Event)]
-pub struct SyncStateEvent<C: StateEventContent> {
+pub struct OriginalSyncStateEvent<C: StateEventContent> {
     /// Data specific to the event type.
     pub content: C,
 

crates/ruma-common/src/events/policy/rule/room.rs

@@ -22,7 +22,7 @@ mod tests {
     use js_int::int;
     use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
 
-    use super::{PolicyRuleRoomEvent, PolicyRuleRoomEventContent};
+    use super::{OriginalPolicyRuleRoomEvent, PolicyRuleRoomEventContent};
     use crate::{
         event_id,
         events::{
@@ -36,7 +36,7 @@ mod tests {
 
     #[test]
     fn serialization() {
-        let room_event = PolicyRuleRoomEvent {
+        let room_event = OriginalPolicyRuleRoomEvent {
             event_id: event_id!("$143273582443PhrSn:example.org").to_owned(),
             sender: user_id!("@example:example.org").to_owned(),
             origin_server_ts: MilliSecondsSinceUnixEpoch(1_432_735_824_653_u64.try_into().unwrap()),
@@ -89,6 +89,9 @@ mod tests {
             }
         });
 
-        assert!(from_json_value::<Raw<PolicyRuleRoomEvent>>(json).unwrap().deserialize().is_ok());
+        assert!(from_json_value::<Raw<OriginalPolicyRuleRoomEvent>>(json)
+            .unwrap()
+            .deserialize()
+            .is_ok());
     }
 }

crates/ruma-common/src/events/relation.rs

@@ -5,7 +5,7 @@ use std::fmt::Debug;
 use js_int::UInt;
 use serde::{Deserialize, Serialize};
 
-use super::AnySyncMessageLikeEvent;
+use super::AnyOriginalSyncMessageLikeEvent;
 use crate::{serde::Raw, EventId, MilliSecondsSinceUnixEpoch, UserId};
 
 /// Summary of all reactions with the given key to an event.
@@ -98,7 +98,7 @@ impl BundledReplacement {
 #[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
 pub struct BundledThread {
     /// The latest event in the thread.
-    pub latest_event: Box<Raw<AnySyncMessageLikeEvent>>,
+    pub latest_event: Box<Raw<AnyOriginalSyncMessageLikeEvent>>,
 
     /// The number of events in the thread.
     pub count: UInt,
@@ -111,7 +111,7 @@ pub struct BundledThread {
 impl BundledThread {
     /// Creates a new `BundledThread` with the given event, count and user participated flag.
     pub fn new(
-        latest_event: Box<Raw<AnySyncMessageLikeEvent>>,
+        latest_event: Box<Raw<AnyOriginalSyncMessageLikeEvent>>,
         count: UInt,
         current_user_participated: bool,
     ) -> Self {

crates/ruma-common/src/events/room/canonical_alias.rs

@@ -44,11 +44,11 @@ mod tests {
     use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
 
     use super::RoomCanonicalAliasEventContent;
-    use crate::events::{StateEvent, StateUnsigned};
+    use crate::events::{OriginalStateEvent, StateUnsigned};
 
     #[test]
     fn serialization_with_optional_fields_as_none() {
-        let canonical_alias_event = StateEvent {
+        let canonical_alias_event = OriginalStateEvent {
             content: RoomCanonicalAliasEventContent {
                 alias: Some(room_alias_id!("#somewhere:localhost").to_owned()),
                 alt_aliases: Vec::new(),
@@ -90,7 +90,7 @@ mod tests {
         });
 
         assert_eq!(
-            from_json_value::<StateEvent<RoomCanonicalAliasEventContent>>(json_data)
+            from_json_value::<OriginalStateEvent<RoomCanonicalAliasEventContent>>(json_data)
                 .unwrap()
                 .content
                 .alias,
@@ -112,7 +112,7 @@ mod tests {
             "type": "m.room.canonical_alias"
         });
         assert_eq!(
-            from_json_value::<StateEvent<RoomCanonicalAliasEventContent>>(json_data)
+            from_json_value::<OriginalStateEvent<RoomCanonicalAliasEventContent>>(json_data)
                 .unwrap()
                 .content
                 .alias,
@@ -134,7 +134,7 @@ mod tests {
             "type": "m.room.canonical_alias"
         });
         assert_eq!(
-            from_json_value::<StateEvent<RoomCanonicalAliasEventContent>>(json_data)
+            from_json_value::<OriginalStateEvent<RoomCanonicalAliasEventContent>>(json_data)
                 .unwrap()
                 .content
                 .alias,
@@ -157,7 +157,7 @@ mod tests {
             "type": "m.room.canonical_alias"
         });
         assert_eq!(
-            from_json_value::<StateEvent<RoomCanonicalAliasEventContent>>(json_data)
+            from_json_value::<OriginalStateEvent<RoomCanonicalAliasEventContent>>(json_data)
                 .unwrap()
                 .content
                 .alias,

crates/ruma-common/src/events/room/join_rules.rs

@@ -221,7 +221,7 @@ mod tests {
     use crate::room_id;
     use matches::assert_matches;
 
-    use super::{AllowRule, JoinRule, RoomJoinRulesEventContent, SyncRoomJoinRulesEvent};
+    use super::{AllowRule, JoinRule, OriginalSyncRoomJoinRulesEvent, RoomJoinRulesEventContent};
 
     #[test]
     fn deserialize() {
@@ -277,6 +277,6 @@ mod tests {
             "event_id": "$0ACb9KSPlT3al3kikyRYvFhMqXPP9ZcQOBrsdIuh58U"
         }"#;
 
-        assert_matches!(serde_json::from_str::<SyncRoomJoinRulesEvent>(json), Ok(_));
+        assert_matches!(serde_json::from_str::<OriginalSyncRoomJoinRulesEvent>(json), Ok(_));
     }
 }

crates/ruma-common/src/events/room/member.rs

@@ -10,8 +10,8 @@ use serde_json::value::RawValue as RawJsonValue;
 
 use crate::{
     events::{
-        EventContent, HasDeserializeFields, RedactContent, RedactedEventContent, StateEventType,
+        EventContent, HasDeserializeFields, OriginalSyncStateEvent, RedactContent,
-        StrippedStateEvent, SyncStateEvent,
+        RedactedEventContent, StateEventType, StrippedStateEvent,
     },
     serde::StringEnum,
     MxcUri, PrivOwnedStr, RoomVersionId, ServerName, ServerSigningKeyId, UserId,
@@ -377,7 +377,7 @@ fn membership_change(
     }
 }
 
-impl RoomMemberEvent {
+impl OriginalRoomMemberEvent {
     /// Helper function for membership change.
     ///
     /// Check [the specification][spec] for details.
@@ -393,7 +393,7 @@ impl RoomMemberEvent {
     }
 }
 
-impl SyncStateEvent<RoomMemberEventContent> {
+impl OriginalSyncStateEvent<RoomMemberEventContent> {
     /// Helper function for membership change.
     ///
     /// Check [the specification][spec] for details.
@@ -429,7 +429,7 @@ mod tests {
     use serde_json::{from_value as from_json_value, json};
 
     use super::{MembershipState, RoomMemberEventContent, SignedContent, ThirdPartyInvite};
-    use crate::events::{StateEvent, StateUnsigned};
+    use crate::events::{OriginalStateEvent, StateUnsigned};
 
     #[test]
     fn serde_with_no_prev_content() {
@@ -446,8 +446,8 @@ mod tests {
         });
 
         assert_matches!(
-            from_json_value::<StateEvent<RoomMemberEventContent>>(json).unwrap(),
+            from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap(),
-            StateEvent {
+            OriginalStateEvent {
                 content: RoomMemberEventContent {
                     avatar_url: None,
                     displayname: None,
@@ -490,7 +490,7 @@ mod tests {
             },
         });
 
-        let ev = from_json_value::<StateEvent<RoomMemberEventContent>>(json).unwrap();
+        let ev = from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap();
 
         assert_matches!(
             ev.content,
@@ -556,8 +556,8 @@ mod tests {
         });
 
         assert_matches!(
-            from_json_value::<StateEvent<RoomMemberEventContent>>(json).unwrap(),
+            from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap(),
-            StateEvent {
+            OriginalStateEvent {
                 content: RoomMemberEventContent {
                     avatar_url: Some(avatar_url),
                     displayname: Some(displayname),
@@ -629,8 +629,8 @@ mod tests {
         });
 
         assert_matches!(
-            from_json_value::<StateEvent<RoomMemberEventContent>>(json).unwrap(),
+            from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap(),
-            StateEvent {
+            OriginalStateEvent {
                 content: RoomMemberEventContent {
                     avatar_url: None,
                     displayname: None,
@@ -692,8 +692,8 @@ mod tests {
         });
 
         assert_matches!(
-            from_json_value::<StateEvent<RoomMemberEventContent>>(json).unwrap(),
+            from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap(),
-            StateEvent {
+            OriginalStateEvent {
                 content: RoomMemberEventContent {
                     avatar_url: None,
                     displayname: None,

crates/ruma-common/src/events/room/message.rs

@@ -127,11 +127,11 @@ impl RoomMessageEventContent {
     /// [`RoomMessageEvent`] since it creates a permalink to the previous message, for which the
     /// room ID is required. If you want to reply to a [`SyncRoomMessageEvent`], you have to convert
     /// it first by calling
-    /// [`.into_full_event()`][crate::events::SyncMessageLikeEvent::into_full_event].
+    /// [`.into_full_event()`][crate::events::OriginalSyncMessageLikeEvent::into_full_event].
     pub fn text_reply_html(
         reply: impl fmt::Display,
         html_reply: impl fmt::Display,
-        original_message: &RoomMessageEvent,
+        original_message: &OriginalRoomMessageEvent,
     ) -> Self {
         let quoted = reply::get_plain_quote_fallback(original_message);
         let quoted_html = reply::get_html_quote_fallback(original_message);
@@ -169,11 +169,11 @@ impl RoomMessageEventContent {
     /// [`RoomMessageEvent`] since it creates a permalink to the previous message, for which the
     /// room ID is required. If you want to reply to a [`SyncRoomMessageEvent`], you have to convert
     /// it first by calling
-    /// [`.into_full_event()`][crate::events::SyncMessageLikeEvent::into_full_event].
+    /// [`.into_full_event()`][crate::events::OriginalSyncMessageLikeEvent::into_full_event].
     pub fn notice_reply_html(
         reply: impl fmt::Display,
         html_reply: impl fmt::Display,
-        original_message: &RoomMessageEvent,
+        original_message: &OriginalRoomMessageEvent,
     ) -> Self {
         let quoted = reply::get_plain_quote_fallback(original_message);
         let quoted_html = reply::get_html_quote_fallback(original_message);

crates/ruma-common/src/events/room/message/reply.rs

@@ -1,7 +1,8 @@
 use indoc::formatdoc;
 
 use super::{
-    FormattedBody, MessageType, RoomMessageEvent, RoomMessageEventContent, SyncRoomMessageEvent,
+    FormattedBody, MessageType, OriginalRoomMessageEvent, OriginalSyncRoomMessageEvent,
+    RoomMessageEventContent,
 };
 use crate::{EventId, UserId};
 
@@ -21,7 +22,7 @@ pub trait ReplyBaseEvent {
     fn content(&self) -> &RoomMessageEventContent;
 }
 
-impl ReplyBaseEvent for RoomMessageEvent {
+impl ReplyBaseEvent for OriginalRoomMessageEvent {
     fn event_id(&self) -> &EventId {
         &self.event_id
     }
@@ -35,7 +36,7 @@ impl ReplyBaseEvent for RoomMessageEvent {
     }
 }
 
-impl ReplyBaseEvent for SyncRoomMessageEvent {
+impl ReplyBaseEvent for OriginalSyncRoomMessageEvent {
     fn event_id(&self) -> &EventId {
         &self.event_id
     }
@@ -91,7 +92,7 @@ pub fn get_plain_quote_fallback(original_message: &impl ReplyBaseEvent) -> Strin
 }
 
 #[allow(clippy::nonstandard_macro_braces)]
-pub fn get_html_quote_fallback(original_message: &RoomMessageEvent) -> String {
+pub fn get_html_quote_fallback(original_message: &OriginalRoomMessageEvent) -> String {
     match &original_message.content.msgtype {
         MessageType::Audio(_) => {
             formatdoc!(
@@ -303,12 +304,12 @@ mod tests {
         event_id, events::MessageLikeUnsigned, room_id, user_id, MilliSecondsSinceUnixEpoch,
     };
 
-    use super::{RoomMessageEvent, RoomMessageEventContent};
+    use super::{OriginalRoomMessageEvent, RoomMessageEventContent};
 
     #[test]
     fn plain_quote_fallback_multiline() {
         assert_eq!(
-            super::get_plain_quote_fallback(&RoomMessageEvent {
+            super::get_plain_quote_fallback(&OriginalRoomMessageEvent {
                 content: RoomMessageEventContent::text_plain("multi\nline"),
                 event_id: event_id!("$1598361704261elfgc:localhost").to_owned(),
                 sender: user_id!("@alice:example.com").to_owned(),

crates/ruma-common/src/events/room/name.rs

@@ -36,11 +36,11 @@ mod tests {
     use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
 
     use super::RoomNameEventContent;
-    use crate::events::{StateEvent, StateUnsigned};
+    use crate::events::{OriginalStateEvent, StateUnsigned};
 
     #[test]
     fn serialization_with_optional_fields_as_none() {
-        let name_event = StateEvent {
+        let name_event = OriginalStateEvent {
             content: RoomNameEventContent { name: "The room name".try_into().ok() },
             event_id: event_id!("$h29iv0s8:example.com").to_owned(),
             origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)),
@@ -68,7 +68,7 @@ mod tests {
 
     #[test]
     fn serialization_with_all_fields() {
-        let name_event = StateEvent {
+        let name_event = OriginalStateEvent {
             content: RoomNameEventContent { name: "The room name".try_into().ok() },
             event_id: event_id!("$h29iv0s8:example.com").to_owned(),
             origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)),
@@ -114,7 +114,10 @@ mod tests {
             "type": "m.room.name"
         });
         assert_eq!(
-            from_json_value::<StateEvent<RoomNameEventContent>>(json_data).unwrap().content.name,
+            from_json_value::<OriginalStateEvent<RoomNameEventContent>>(json_data)
+                .unwrap()
+                .content
+                .name,
             None
         );
     }
@@ -161,7 +164,10 @@ mod tests {
             "type": "m.room.name"
         });
         assert_eq!(
-            from_json_value::<StateEvent<RoomNameEventContent>>(json_data).unwrap().content.name,
+            from_json_value::<OriginalStateEvent<RoomNameEventContent>>(json_data)
+                .unwrap()
+                .content
+                .name,
             None
         );
     }
@@ -180,7 +186,10 @@ mod tests {
             "type": "m.room.name"
         });
         assert_eq!(
-            from_json_value::<StateEvent<RoomNameEventContent>>(json_data).unwrap().content.name,
+            from_json_value::<OriginalStateEvent<RoomNameEventContent>>(json_data)
+                .unwrap()
+                .content
+                .name,
             None
         );
     }
@@ -201,7 +210,10 @@ mod tests {
         });
 
         assert_eq!(
-            from_json_value::<StateEvent<RoomNameEventContent>>(json_data).unwrap().content.name,
+            from_json_value::<OriginalStateEvent<RoomNameEventContent>>(json_data)
+                .unwrap()
+                .content
+                .name,
             name
         );
     }

crates/ruma-common/src/events/room/pinned_events.rs

@@ -32,7 +32,7 @@ mod tests {
     use crate::{server_name, EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId};
 
     use super::RoomPinnedEventsEventContent;
-    use crate::events::{StateEvent, StateUnsigned};
+    use crate::events::{OriginalStateEvent, StateUnsigned};
 
     #[test]
     fn serialization_deserialization() {
@@ -43,7 +43,7 @@ mod tests {
         content.pinned.push(EventId::new(server_name));
         content.pinned.push(EventId::new(server_name));
 
-        let event = StateEvent {
+        let event = OriginalStateEvent {
             content: content.clone(),
             event_id: EventId::new(server_name),
             origin_server_ts: MilliSecondsSinceUnixEpoch(1_432_804_485_886_u64.try_into().unwrap()),
@@ -54,7 +54,7 @@ mod tests {
         };
 
         let serialized_event = serde_json::to_string(&event).unwrap();
-        let parsed_event: StateEvent<RoomPinnedEventsEventContent> =
+        let parsed_event: OriginalStateEvent<RoomPinnedEventsEventContent> =
             serde_json::from_str(&serialized_event).unwrap();
 
         assert_eq!(parsed_event.event_id, event.event_id);

crates/ruma-common/src/events/room/power_levels.rs

@@ -182,13 +182,13 @@ mod tests {
     use serde_json::{json, to_value as to_json_value};
 
     use super::{default_power_level, NotificationPowerLevels, RoomPowerLevelsEventContent};
-    use crate::events::{StateEvent, StateUnsigned};
+    use crate::events::{OriginalStateEvent, StateUnsigned};
 
     #[test]
     fn serialization_with_optional_fields_as_none() {
         let default = default_power_level();
 
-        let power_levels_event = StateEvent {
+        let power_levels_event = OriginalStateEvent {
             content: RoomPowerLevelsEventContent {
                 ban: default,
                 events: BTreeMap::new(),
@@ -226,7 +226,7 @@ mod tests {
     #[test]
     fn serialization_with_all_fields() {
         let user = user_id!("@carl:example.com");
-        let power_levels_event = StateEvent {
+        let power_levels_event = OriginalStateEvent {
             content: RoomPowerLevelsEventContent {
                 ban: int!(23),
                 events: btreemap! {

crates/ruma-common/src/events/room/redaction.rs

@@ -13,7 +13,7 @@ use crate::{
 /// Redaction event.
 #[derive(Clone, Debug, Event)]
 #[allow(clippy::exhaustive_structs)]
-pub struct RoomRedactionEvent {
+pub struct OriginalRoomRedactionEvent {
     /// Data specific to the event type.
     pub content: RoomRedactionEventContent,
 
@@ -36,12 +36,12 @@ pub struct RoomRedactionEvent {
     pub unsigned: MessageLikeUnsigned,
 }
 
-impl Redact for RoomRedactionEvent {
+impl Redact for OriginalRoomRedactionEvent {
     type Redacted = RedactedRoomRedactionEvent;
 
     fn redact(
         self,
-        redaction: SyncRoomRedactionEvent,
+        redaction: OriginalSyncRoomRedactionEvent,
         version: &crate::RoomVersionId,
     ) -> Self::Redacted {
         RedactedRoomRedactionEvent {
@@ -86,7 +86,7 @@ pub struct RedactedRoomRedactionEvent {
 /// Redaction event without a `room_id`.
 #[derive(Clone, Debug, Event)]
 #[allow(clippy::exhaustive_structs)]
-pub struct SyncRoomRedactionEvent {
+pub struct OriginalSyncRoomRedactionEvent {
     /// Data specific to the event type.
     pub content: RoomRedactionEventContent,
 
@@ -106,12 +106,12 @@ pub struct SyncRoomRedactionEvent {
     pub unsigned: MessageLikeUnsigned,
 }
 
-impl Redact for SyncRoomRedactionEvent {
+impl Redact for OriginalSyncRoomRedactionEvent {
     type Redacted = RedactedSyncRoomRedactionEvent;
 
     fn redact(
         self,
-        redaction: SyncRoomRedactionEvent,
+        redaction: OriginalSyncRoomRedactionEvent,
         version: &crate::RoomVersionId,
     ) -> Self::Redacted {
         RedactedSyncRoomRedactionEvent {

crates/ruma-common/src/events/room/server_acl.rs

@@ -68,7 +68,7 @@ mod tests {
     use serde_json::{from_value as from_json_value, json};
 
     use super::RoomServerAclEventContent;
-    use crate::events::StateEvent;
+    use crate::events::OriginalStateEvent;
 
     #[test]
     fn default_values() {
@@ -82,7 +82,7 @@ mod tests {
             "type": "m.room.server_acl"
         });
 
-        let server_acl_event: StateEvent<RoomServerAclEventContent> =
+        let server_acl_event: OriginalStateEvent<RoomServerAclEventContent> =
             from_json_value(json_data).unwrap();
 
         assert!(server_acl_event.content.allow_ip_literals);

crates/ruma-common/src/events/unsigned.rs

@@ -4,7 +4,7 @@ use serde_json::{from_str as from_json_str, value::RawValue as RawJsonValue};
 
 #[cfg(feature = "unstable-msc2675")]
 use super::relation::Relations;
-use super::{room::redaction::SyncRoomRedactionEvent, StateEventContent};
+use super::{room::redaction::OriginalSyncRoomRedactionEvent, StateEventContent};
 use crate::{serde::Raw, TransactionId};
 
 /// Extra information about a message event that is not incorporated into the event's hash.
@@ -172,7 +172,7 @@ impl<C: StateEventContent> Default for StateUnsigned<C> {
 pub struct RedactedUnsigned {
     /// The event that redacted this event, if any.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub redacted_because: Option<Box<SyncRoomRedactionEvent>>,
+    pub redacted_because: Option<Box<OriginalSyncRoomRedactionEvent>>,
 }
 
 impl RedactedUnsigned {
@@ -182,7 +182,7 @@ impl RedactedUnsigned {
     }
 
     /// Create a new `RedactedUnsigned` with the given redacted because.
-    pub fn new_because(redacted_because: Box<SyncRoomRedactionEvent>) -> Self {
+    pub fn new_because(redacted_because: Box<OriginalSyncRoomRedactionEvent>) -> Self {
         Self { redacted_because: Some(redacted_because) }
     }
 

crates/ruma-common/tests/events/audio.rs

@@ -17,7 +17,7 @@ use ruma_common::{
             },
             JsonWebKeyInit, MediaSource,
         },
-        AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
+        AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
     },
     mxc_uri, room_id,
     serde::Base64,
@@ -137,7 +137,7 @@ fn encrypted_content_serialization() {
 
 #[test]
 fn event_serialization() {
-    let event = MessageLikeEvent {
+    let event = OriginalMessageLikeEvent {
         content: assign!(
             AudioEventContent::with_message(
                 MessageContent::html(
@@ -349,8 +349,8 @@ fn message_event_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Audio(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Audio(OriginalMessageLikeEvent {
             content: AudioEventContent {
                 message,
                 file: FileContent {

crates/ruma-common/tests/events/enums.rs

@@ -10,11 +10,12 @@ use ruma_common::{
             message::{MessageType, RoomMessageEventContent, TextMessageEventContent},
             power_levels::RoomPowerLevelsEventContent,
         },
-        AnyEphemeralRoomEvent, AnyMessageLikeEvent, AnyRoomEvent, AnyStateEvent,
+        AnyEphemeralRoomEvent, AnyOriginalMessageLikeEvent, AnyOriginalStateEvent,
-        AnyStateEventContent, AnySyncMessageLikeEvent, AnySyncRoomEvent, AnySyncStateEvent,
+        AnyOriginalSyncMessageLikeEvent, AnyOriginalSyncStateEvent, AnyRoomEvent,
-        EphemeralRoomEventType, GlobalAccountDataEventType, MessageLikeEvent, MessageLikeEventType,
+        AnyStateEventContent, AnySyncRoomEvent, EphemeralRoomEventType, GlobalAccountDataEventType,
-        MessageLikeUnsigned, RoomAccountDataEventType, StateEvent, StateEventType,
+        MessageLikeEventType, MessageLikeUnsigned, OriginalMessageLikeEvent, OriginalStateEvent,
-        SyncMessageLikeEvent, SyncStateEvent, ToDeviceEventType,
+        OriginalSyncMessageLikeEvent, OriginalSyncStateEvent, RoomAccountDataEventType,
+        StateEventType, ToDeviceEventType,
     },
     MilliSecondsSinceUnixEpoch,
 };
@@ -123,8 +124,8 @@ fn power_event_sync_deserialization() {
 
     assert_matches!(
         from_json_value::<AnySyncRoomEvent>(json_data),
-        Ok(AnySyncRoomEvent::State(
+        Ok(AnySyncRoomEvent::OriginalState(
-            AnySyncStateEvent::RoomPowerLevels(SyncStateEvent {
+            AnyOriginalSyncStateEvent::RoomPowerLevels(OriginalSyncStateEvent {
                 content: RoomPowerLevelsEventContent {
                     ban, ..
                 },
@@ -141,8 +142,8 @@ fn message_event_sync_deserialization() {
 
     assert_matches!(
         from_json_value::<AnySyncRoomEvent>(json_data),
-        Ok(AnySyncRoomEvent::MessageLike(
+        Ok(AnySyncRoomEvent::OriginalMessageLike(
-            AnySyncMessageLikeEvent::RoomMessage(SyncMessageLikeEvent {
+            AnyOriginalSyncMessageLikeEvent::RoomMessage(OriginalSyncMessageLikeEvent {
                 content: RoomMessageEventContent {
                     msgtype: MessageType::Text(TextMessageEventContent {
                         body,
@@ -164,8 +165,8 @@ fn aliases_event_sync_deserialization() {
 
     assert_matches!(
         from_json_value::<AnySyncRoomEvent>(json_data),
-        Ok(AnySyncRoomEvent::State(
+        Ok(AnySyncRoomEvent::OriginalState(
-            AnySyncStateEvent::RoomAliases(SyncStateEvent {
+            AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent {
                 content: RoomAliasesEventContent {
                     aliases,
                     ..
@@ -183,8 +184,8 @@ fn message_room_event_deserialization() {
 
     assert_matches!(
         from_json_value::<AnyRoomEvent>(json_data),
-        Ok(AnyRoomEvent::MessageLike(
+        Ok(AnyRoomEvent::OriginalMessageLike(
-            AnyMessageLikeEvent::RoomMessage(MessageLikeEvent {
+            AnyOriginalMessageLikeEvent::RoomMessage(OriginalMessageLikeEvent {
                 content: RoomMessageEventContent {
                     msgtype: MessageType::Text(TextMessageEventContent {
                         body,
@@ -202,7 +203,7 @@ fn message_room_event_deserialization() {
 
 #[test]
 fn message_event_serialization() {
-    let event = MessageLikeEvent {
+    let event = OriginalMessageLikeEvent {
         content: RoomMessageEventContent::text_plain("test"),
         event_id: event_id!("$1234:example.com").to_owned(),
         origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(0)),
@@ -230,8 +231,8 @@ fn alias_room_event_deserialization() {
 
     assert_matches!(
         from_json_value::<AnyRoomEvent>(json_data),
-        Ok(AnyRoomEvent::State(
+        Ok(AnyRoomEvent::OriginalState(
-            AnyStateEvent::RoomAliases(StateEvent {
+            AnyOriginalStateEvent::RoomAliases(OriginalStateEvent {
                 content: RoomAliasesEventContent {
                     aliases,
                     ..
@@ -249,8 +250,8 @@ fn message_event_deserialization() {
 
     assert_matches!(
         from_json_value::<AnyRoomEvent>(json_data),
-        Ok(AnyRoomEvent::MessageLike(
+        Ok(AnyRoomEvent::OriginalMessageLike(
-            AnyMessageLikeEvent::RoomMessage(MessageLikeEvent {
+            AnyOriginalMessageLikeEvent::RoomMessage(OriginalMessageLikeEvent {
                 content: RoomMessageEventContent {
                     msgtype: MessageType::Text(TextMessageEventContent {
                         body,
@@ -272,8 +273,8 @@ fn alias_event_deserialization() {
 
     assert_matches!(
         from_json_value::<AnyRoomEvent>(json_data),
-        Ok(AnyRoomEvent::State(
+        Ok(AnyRoomEvent::OriginalState(
-            AnyStateEvent::RoomAliases(StateEvent {
+            AnyOriginalStateEvent::RoomAliases(OriginalStateEvent {
                 content: RoomAliasesEventContent {
                     aliases,
                     ..
@@ -291,14 +292,14 @@ fn alias_event_field_access() {
 
     assert_matches!(
         from_json_value::<AnyRoomEvent>(json_data.clone()),
-        Ok(AnyRoomEvent::State(state_event))
+        Ok(AnyRoomEvent::OriginalState(state_event))
         if state_event.state_key() == ""
             && state_event.room_id() == room_id!("!room:room.com")
             && state_event.event_id() == event_id!("$152037280074GZeOm:localhost")
             && state_event.sender() == user_id!("@example:localhost")
     );
 
-    let deser = from_json_value::<AnyStateEvent>(json_data).unwrap();
+    let deser = from_json_value::<AnyOriginalStateEvent>(json_data).unwrap();
     if let AnyStateEventContent::RoomAliases(RoomAliasesEventContent { aliases, .. }) =
         deser.content()
     {

crates/ruma-common/tests/events/event_enums.rs

@@ -5,7 +5,7 @@ use serde_json::{from_value as from_json_value, json};
 
 use ruma_common::events::{
     call::{answer::CallAnswerEventContent, SessionDescription, SessionDescriptionType},
-    AnyMessageLikeEvent, MessageLikeEvent,
+    AnyOriginalMessageLikeEvent, OriginalMessageLikeEvent,
 };
 
 #[test]
@@ -35,9 +35,9 @@ fn deserialize_message_event() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data)
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data)
             .unwrap(),
-        AnyMessageLikeEvent::CallAnswer(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent {
             content: CallAnswerEventContent {
                 answer: SessionDescription {
                     session_type: SessionDescriptionType::Answer,

crates/ruma-common/tests/events/file.rs

@@ -14,7 +14,7 @@ use ruma_common::{
             },
             EncryptedFileInit, JsonWebKeyInit, MediaSource,
         },
-        AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
+        AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
     },
     mxc_uri, room_id,
     serde::Base64,
@@ -92,7 +92,7 @@ fn encrypted_content_serialization() {
 
 #[test]
 fn file_event_serialization() {
-    let event = MessageLikeEvent {
+    let event = OriginalMessageLikeEvent {
         content: assign!(
             FileEventContent::plain_message(
                 MessageContent::html(
@@ -225,8 +225,8 @@ fn message_event_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::File(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::File(OriginalMessageLikeEvent {
             content: FileEventContent {
                 message,
                 file: FileContent {

crates/ruma-common/tests/events/image.rs

@@ -18,7 +18,7 @@ use ruma_common::{
             },
             JsonWebKeyInit, MediaSource,
         },
-        AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
+        AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
     },
     mxc_uri, room_id,
     serde::Base64,
@@ -99,7 +99,7 @@ fn encrypted_content_serialization() {
 
 #[test]
 fn image_event_serialization() {
-    let event = MessageLikeEvent {
+    let event = OriginalMessageLikeEvent {
         content: assign!(
             ImageEventContent::with_message(
                 MessageContent::html(
@@ -285,8 +285,8 @@ fn message_event_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Image(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Image(OriginalMessageLikeEvent {
             content: ImageEventContent {
                 message,
                 file: FileContent {

crates/ruma-common/tests/events/location.rs

@@ -14,7 +14,7 @@ use ruma_common::{
         room::message::{
             InReplyTo, LocationMessageEventContent, MessageType, Relation, RoomMessageEventContent,
         },
-        AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
+        AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
     },
     room_id, user_id, MilliSecondsSinceUnixEpoch,
 };
@@ -40,7 +40,7 @@ fn plain_content_serialization() {
 
 #[test]
 fn event_serialization() {
-    let event = MessageLikeEvent {
+    let event = OriginalMessageLikeEvent {
         content: assign!(
             LocationEventContent::with_message(
                 MessageContent::html(
@@ -195,8 +195,8 @@ fn message_event_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Location(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Location(OriginalMessageLikeEvent {
             content: LocationEventContent {
                 message,
                 location: LocationContent {

crates/ruma-common/tests/events/message.rs

@@ -15,7 +15,7 @@ use ruma_common::{
             EmoteMessageEventContent, InReplyTo, MessageType, NoticeMessageEventContent, Relation,
             RoomMessageEventContent, TextMessageEventContent,
         },
-        AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
+        AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
     },
     room_id, user_id, MilliSecondsSinceUnixEpoch,
 };
@@ -126,7 +126,7 @@ fn relates_to_content_serialization() {
 
 #[test]
 fn message_event_serialization() {
-    let event = MessageLikeEvent {
+    let event = OriginalMessageLikeEvent {
         content: MessageEventContent::plain("Hello, World!"),
         event_id: event_id!("$event:notareal.hs").to_owned(),
         sender: user_id!("@user:notareal.hs").to_owned(),
@@ -255,8 +255,8 @@ fn message_event_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Message(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Message(OriginalMessageLikeEvent {
             content: MessageEventContent {
                 message,
                 ..
@@ -391,7 +391,7 @@ fn room_message_html_text_unstable_deserialization() {
 
 #[test]
 fn notice_event_serialization() {
-    let event = MessageLikeEvent {
+    let event = OriginalMessageLikeEvent {
         content: NoticeEventContent::plain("Hello, I'm a robot!"),
         event_id: event_id!("$event:notareal.hs").to_owned(),
         sender: user_id!("@user:notareal.hs").to_owned(),
@@ -447,8 +447,8 @@ fn notice_event_stable_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Notice(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Notice(OriginalMessageLikeEvent {
             content: NoticeEventContent {
                 message,
                 ..
@@ -485,8 +485,8 @@ fn notice_event_unstable_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Notice(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Notice(OriginalMessageLikeEvent {
             content: NoticeEventContent {
                 message,
                 ..
@@ -558,7 +558,7 @@ fn room_message_notice_unstable_deserialization() {
 
 #[test]
 fn emote_event_serialization() {
-    let event = MessageLikeEvent {
+    let event = OriginalMessageLikeEvent {
         content: EmoteEventContent::html(
             "is testing some code…",
             "is testing some <code>code</code>…",
@@ -618,8 +618,8 @@ fn emote_event_stable_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Emote(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Emote(OriginalMessageLikeEvent {
             content: EmoteEventContent {
                 message,
                 ..
@@ -653,8 +653,8 @@ fn emote_event_unstable_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Emote(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Emote(OriginalMessageLikeEvent {
             content: EmoteEventContent {
                 message,
                 ..

crates/ruma-common/tests/events/message_event.rs

@@ -7,8 +7,8 @@ use ruma_common::{
         call::{answer::CallAnswerEventContent, SessionDescription, SessionDescriptionType},
         room::{ImageInfo, MediaSource, ThumbnailInfo},
         sticker::StickerEventContent,
-        AnyMessageLikeEvent, AnyMessageLikeEventContent, AnySyncMessageLikeEvent, MessageLikeEvent,
+        AnyMessageLikeEventContent, AnyOriginalMessageLikeEvent, AnyOriginalSyncMessageLikeEvent,
-        MessageLikeEventType, MessageLikeUnsigned,
+        MessageLikeEventType, MessageLikeUnsigned, OriginalMessageLikeEvent,
     },
     mxc_uri, room_id,
     serde::Raw,
@@ -18,7 +18,7 @@ use serde_json::{from_value as from_json_value, json, to_value as to_json_value}
 
 #[test]
 fn message_serialize_sticker() {
-    let aliases_event = MessageLikeEvent {
+    let aliases_event = OriginalMessageLikeEvent {
         content: StickerEventContent::new(
             "Hello".into(),
             assign!(ImageInfo::new(), {
@@ -167,8 +167,8 @@ fn deserialize_message_call_answer() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::CallAnswer(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent {
             content: CallAnswerEventContent {
                 answer: SessionDescription {
                     session_type: SessionDescriptionType::Answer,
@@ -221,8 +221,8 @@ fn deserialize_message_sticker() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Sticker(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Sticker(OriginalMessageLikeEvent {
             content: StickerEventContent {
                 body,
                 info: ImageInfo {
@@ -290,11 +290,11 @@ fn deserialize_message_then_convert_to_full() {
         "type": "m.call.answer"
     });
 
-    let sync_ev: AnySyncMessageLikeEvent = from_json_value(json_data).unwrap();
+    let sync_ev: AnyOriginalSyncMessageLikeEvent = from_json_value(json_data).unwrap();
 
     assert_matches!(
         sync_ev.into_full_event(rid.to_owned()),
-        AnyMessageLikeEvent::CallAnswer(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent {
             content: CallAnswerEventContent {
                 answer: SessionDescription {
                     session_type: SessionDescriptionType::Answer,

crates/ruma-common/tests/events/redacted.rs

@@ -7,9 +7,9 @@ use ruma_common::{
             aliases::RedactedRoomAliasesEventContent,
             create::{RedactedRoomCreateEventContent, RoomCreateEventContent},
             message::{RedactedRoomMessageEventContent, RoomMessageEventContent},
-            redaction::{RoomRedactionEventContent, SyncRoomRedactionEvent},
+            redaction::{OriginalSyncRoomRedactionEvent, RoomRedactionEventContent},
         },
-        AnyMessageLikeEvent, AnyRedactedMessageLikeEvent, AnyRedactedSyncMessageLikeEvent,
+        AnyOriginalMessageLikeEvent, AnyRedactedMessageLikeEvent, AnyRedactedSyncMessageLikeEvent,
         AnyRedactedSyncStateEvent, AnyRoomEvent, AnySyncRoomEvent, EventContent,
         MessageLikeUnsigned, Redact, RedactContent, RedactedMessageLikeEvent,
         RedactedSyncMessageLikeEvent, RedactedSyncStateEvent, RedactedUnsigned,
@@ -23,7 +23,7 @@ use serde_json::{
 
 fn unsigned() -> RedactedUnsigned {
     let mut unsigned = RedactedUnsigned::default();
-    unsigned.redacted_because = Some(Box::new(SyncRoomRedactionEvent {
+    unsigned.redacted_because = Some(Box::new(OriginalSyncRoomRedactionEvent {
         content: RoomRedactionEventContent::with_reason("redacted because".into()),
         redacts: event_id!("$h29iv0s8:example.com").to_owned(),
         event_id: event_id!("$h29iv0s8:example.com").to_owned(),
@@ -160,7 +160,7 @@ fn redacted_deserialize_any_room_sync() {
     // The presence of `redacted_because` triggers the event enum (AnySyncRoomEvent in this case)
     // to return early with `RedactedContent` instead of failing to deserialize according
     // to the event type string.
-    unsigned.redacted_because = Some(Box::new(SyncRoomRedactionEvent {
+    unsigned.redacted_because = Some(Box::new(OriginalSyncRoomRedactionEvent {
         content: RoomRedactionEventContent::with_reason("redacted because".into()),
         redacts: event_id!("$h29iv0s8:example.com").to_owned(),
         event_id: event_id!("$h29iv0s8:example.com").to_owned(),
@@ -260,7 +260,7 @@ fn redact_method_properly_redacts() {
         },
     });
 
-    let redaction = SyncRoomRedactionEvent {
+    let redaction = OriginalSyncRoomRedactionEvent {
         content: RoomRedactionEventContent::with_reason("redacted because".into()),
         redacts: event_id!("$143273582443PhrSn:example.com").to_owned(),
         event_id: event_id!("$h29iv0s8:example.com").to_owned(),
@@ -269,7 +269,7 @@ fn redact_method_properly_redacts() {
         unsigned: MessageLikeUnsigned::default(),
     };
 
-    let event: AnyMessageLikeEvent = from_json_value(ev).unwrap();
+    let event: AnyOriginalMessageLikeEvent = from_json_value(ev).unwrap();
 
     assert_matches!(
         event.redact(redaction, &RoomVersionId::V6),

crates/ruma-common/tests/events/redaction.rs

@@ -3,8 +3,8 @@ use matches::assert_matches;
 use ruma_common::{
     event_id,
     events::{
-        room::redaction::{RoomRedactionEvent, RoomRedactionEventContent},
+        room::redaction::{OriginalRoomRedactionEvent, RoomRedactionEventContent},
-        AnyMessageLikeEvent, MessageLikeUnsigned,
+        AnyOriginalMessageLikeEvent, MessageLikeUnsigned,
     },
     room_id, user_id, MilliSecondsSinceUnixEpoch,
 };
@@ -28,7 +28,7 @@ fn redaction() -> JsonValue {
 
 #[test]
 fn serialize_redaction() {
-    let aliases_event = RoomRedactionEvent {
+    let aliases_event = OriginalRoomRedactionEvent {
         content: RoomRedactionEventContent::with_reason("being a turd".into()),
         redacts: event_id!("$nomore:example.com").to_owned(),
         event_id: event_id!("$h29iv0s8:example.com").to_owned(),
@@ -49,8 +49,8 @@ fn deserialize_redaction() {
     let json_data = redaction();
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::RoomRedaction(RoomRedactionEvent {
+        AnyOriginalMessageLikeEvent::RoomRedaction(OriginalRoomRedactionEvent {
             content: RoomRedactionEventContent { reason: Some(reas), .. },
             redacts,
             event_id,

crates/ruma-common/tests/events/room_message.rs

@@ -15,7 +15,7 @@ use ruma_common::{
         room::{
             message::{
                 AudioMessageEventContent, KeyVerificationRequestEventContent, MessageType,
-                RoomMessageEvent, RoomMessageEventContent, TextMessageEventContent,
+                OriginalRoomMessageEvent, RoomMessageEventContent, TextMessageEventContent,
             },
             MediaSource,
         },
@@ -39,7 +39,7 @@ macro_rules! json_object {
 
 #[test]
 fn serialization() {
-    let ev = RoomMessageEvent {
+    let ev = OriginalRoomMessageEvent {
         content: RoomMessageEventContent::new(MessageType::Audio(AudioMessageEventContent::plain(
             "test".into(),
             mxc_uri!("mxc://example.org/ffed755USFFxlgbQYZGtryd").to_owned(),

crates/ruma-common/tests/events/state_event.rs

@@ -9,8 +9,8 @@ use ruma_common::{
             avatar::{ImageInfo, RoomAvatarEventContent},
             ThumbnailInfo,
         },
-        AnyRoomEvent, AnyStateEvent, AnyStateEventContent, AnySyncStateEvent, StateEvent,
+        AnyOriginalStateEvent, AnyOriginalSyncStateEvent, AnyRoomEvent, AnyStateEventContent,
-        StateEventType, StateUnsigned, SyncStateEvent,
+        OriginalStateEvent, OriginalSyncStateEvent, StateEventType, StateUnsigned,
     },
     mxc_uri, room_alias_id, room_id,
     serde::Raw,
@@ -41,7 +41,7 @@ fn aliases_event_with_prev_content() -> JsonValue {
 
 #[test]
 fn serialize_aliases_with_prev_content() {
-    let aliases_event = StateEvent {
+    let aliases_event = OriginalStateEvent {
         content: RoomAliasesEventContent::new(vec![
             room_alias_id!("#somewhere:localhost").to_owned()
         ]),
@@ -66,7 +66,7 @@ fn serialize_aliases_with_prev_content() {
 
 #[test]
 fn serialize_aliases_without_prev_content() {
-    let aliases_event = StateEvent {
+    let aliases_event = OriginalStateEvent {
         content: RoomAliasesEventContent::new(vec![
             room_alias_id!("#somewhere:localhost").to_owned()
         ]),
@@ -115,8 +115,8 @@ fn deserialize_aliases_with_prev_content() {
     let json_data = aliases_event_with_prev_content();
 
     assert_matches!(
-        from_json_value::<AnyStateEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalStateEvent>(json_data).unwrap(),
-        AnyStateEvent::RoomAliases(StateEvent {
+        AnyOriginalStateEvent::RoomAliases(OriginalStateEvent {
             content,
             event_id,
             origin_server_ts,
@@ -143,9 +143,9 @@ fn deserialize_aliases_sync_with_room_id() {
     let json_data = aliases_event_with_prev_content();
 
     assert_matches!(
-        from_json_value::<AnySyncStateEvent>(json_data)
+        from_json_value::<AnyOriginalSyncStateEvent>(json_data)
             .unwrap(),
-        AnySyncStateEvent::RoomAliases(SyncStateEvent {
+        AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent {
             content,
             event_id,
             origin_server_ts,
@@ -193,8 +193,8 @@ fn deserialize_avatar_without_prev_content() {
     });
 
     assert_matches!(
-        from_json_value::<AnyStateEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalStateEvent>(json_data).unwrap(),
-        AnyStateEvent::RoomAvatar(StateEvent {
+        AnyOriginalStateEvent::RoomAvatar(OriginalStateEvent {
             content: RoomAvatarEventContent {
                 info: Some(info),
                 url: Some(url),
@@ -268,8 +268,8 @@ fn deserialize_member_event_with_top_level_membership_field() {
     assert_matches!(
         from_json_value::<AnyRoomEvent>(json_data)
             .unwrap(),
-        AnyRoomEvent::State(
+        AnyRoomEvent::OriginalState(
-            AnyStateEvent::RoomMember(StateEvent {
+            AnyOriginalStateEvent::RoomMember(OriginalStateEvent {
                 content,
                 event_id,
                 origin_server_ts,
@@ -287,11 +287,11 @@ fn deserialize_member_event_with_top_level_membership_field() {
 fn deserialize_full_event_convert_to_sync() {
     let json_data = aliases_event_with_prev_content();
 
-    let full_ev: AnyStateEvent = from_json_value(json_data).unwrap();
+    let full_ev: AnyOriginalStateEvent = from_json_value(json_data).unwrap();
 
     assert_matches!(
-        AnySyncStateEvent::from(full_ev),
+        AnyOriginalSyncStateEvent::from(full_ev),
-        AnySyncStateEvent::RoomAliases(SyncStateEvent {
+        AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent {
             content,
             event_id,
             origin_server_ts,

crates/ruma-common/tests/events/ui/04-event-sanity-check.rs

@@ -11,7 +11,7 @@ use ruma_macros::Event;
 
 /// State event.
 #[derive(Clone, Debug, Event)]
-pub struct StateEvent<C: StateEventContent> {
+pub struct OriginalStateEvent<C: StateEventContent> {
     pub content: C,
     pub event_id: Box<EventId>,
     pub sender: Box<UserId>,

crates/ruma-common/tests/events/ui/05-named-fields.rs

@@ -3,6 +3,6 @@ use ruma_macros::Event;
 
 /// State event.
 #[derive(Clone, Debug, Event)]
-pub struct StateEvent<C: StateEventContent>(C);
+pub struct OriginalStateEvent<C: StateEventContent>(C);
 
 fn main() {}

crates/ruma-common/tests/events/ui/05-named-fields.stderr

@@ -1,5 +1,5 @@
 error: the `Event` derive only supports structs with named fields
  --> tests/events/ui/05-named-fields.rs:6:12
   |
-6 | pub struct StateEvent<C: StateEventContent>(C);
+6 | pub struct OriginalStateEvent<C: StateEventContent>(C);
-  |            ^^^^^^^^^^
+  |            ^^^^^^^^^^^^^^^^^^

crates/ruma-common/tests/events/ui/06-no-content-field.rs

@@ -3,7 +3,7 @@ use ruma_macros::Event;
 
 /// State event.
 #[derive(Clone, Debug, Event)]
-pub struct StateEvent<C: StateEventContent> {
+pub struct OriginalStateEvent<C: StateEventContent> {
     pub not_content: C,
 }
 

crates/ruma-common/tests/events/video.rs

@@ -18,7 +18,7 @@ use ruma_common::{
             JsonWebKeyInit, MediaSource,
         },
         video::{VideoContent, VideoEventContent},
-        AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
+        AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
     },
     mxc_uri, room_id,
     serde::Base64,
@@ -99,7 +99,7 @@ fn encrypted_content_serialization() {
 
 #[test]
 fn event_serialization() {
-    let event = MessageLikeEvent {
+    let event = OriginalMessageLikeEvent {
         content: assign!(
             VideoEventContent::with_message(
                 MessageContent::html(
@@ -295,8 +295,8 @@ fn message_event_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Video(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Video(OriginalMessageLikeEvent {
             content: VideoEventContent {
                 message,
                 file: FileContent {

crates/ruma-common/tests/events/voice.rs

@@ -17,7 +17,7 @@ use ruma_common::{
             MediaSource,
         },
         voice::{VoiceContent, VoiceEventContent},
-        AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
+        AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
     },
     mxc_uri, room_id, user_id, MilliSecondsSinceUnixEpoch,
 };
@@ -25,7 +25,7 @@ use serde_json::{from_value as from_json_value, json, to_value as to_json_value}
 
 #[test]
 fn event_serialization() {
-    let event = MessageLikeEvent {
+    let event = OriginalMessageLikeEvent {
         content: assign!(
             VoiceEventContent::plain(
                 "Voice message",
@@ -114,8 +114,8 @@ fn message_event_deserialization() {
     });
 
     assert_matches!(
-        from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
+        from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
-        AnyMessageLikeEvent::Voice(MessageLikeEvent {
+        AnyOriginalMessageLikeEvent::Voice(OriginalMessageLikeEvent {
             content: VoiceEventContent {
                 message,
                 file: FileContent {

crates/ruma-macros/src/events/event.rs

@@ -55,7 +55,7 @@ pub fn expand_event(input: DeriveInput) -> syn::Result<TokenStream> {
     }
 
     if matches!(kind, EventKind::MessageLike | EventKind::State)
-        && matches!(var, EventKindVariation::Full | EventKindVariation::Sync)
+        && matches!(var, EventKindVariation::Original | EventKindVariation::OriginalSync)
     {
         res.extend(expand_redact_event(&input, kind, var, &fields, &ruma_common));
     }
@@ -422,7 +422,7 @@ fn expand_redact_event(
 
             fn redact(
                 self,
-                redaction: #ruma_common::events::room::redaction::SyncRoomRedactionEvent,
+                redaction: #ruma_common::events::room::redaction::OriginalSyncRoomRedactionEvent,
                 version: &#ruma_common::RoomVersionId,
             ) -> Self::Redacted {
                 let content = #ruma_common::events::RedactContent::redact(self.content, version);

crates/ruma-macros/src/events/event_content.rs

@@ -367,8 +367,10 @@ fn generate_event_type_aliases(
     })?;
 
     let type_aliases = [
-        EventKindVariation::Full,
+        EventKindVariation::None,
         EventKindVariation::Sync,
+        EventKindVariation::Original,
+        EventKindVariation::OriginalSync,
         EventKindVariation::Stripped,
         EventKindVariation::Initial,
         EventKindVariation::Redacted,
@@ -380,8 +382,10 @@ fn generate_event_type_aliases(
         let ev_type = format_ident!("{}{}", var, ev_type_s);
 
         let doc_text = match var {
-            EventKindVariation::Full => "",
+            EventKindVariation::None | EventKindVariation::Original => "",
-            EventKindVariation::Sync => " from a `sync_events` response",
+            EventKindVariation::Sync | EventKindVariation::OriginalSync => {
+                " from a `sync_events` response"
+            }
             EventKindVariation::Stripped => " from an invited room preview",
             EventKindVariation::Redacted => " that has been redacted",
             EventKindVariation::RedactedSync => {

crates/ruma-macros/src/events/event_enum.rs

@@ -20,7 +20,12 @@ const EVENT_FIELDS: &[(&str, EventKindFn)] = &[
     ("origin_server_ts", is_non_stripped_room_event),
     ("room_id", |kind, var| {
         matches!(kind, EventKind::MessageLike | EventKind::State | EventKind::Ephemeral)
-            && matches!(var, EventKindVariation::Full | EventKindVariation::Redacted)
+            && matches!(
+                var,
+                EventKindVariation::None
+                    | EventKindVariation::Original
+                    | EventKindVariation::Redacted
+            )
     }),
     ("event_id", is_non_stripped_room_event),
     ("sender", |kind, var| {
@@ -48,25 +53,61 @@ pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> {
     let variants = &variants;
     let ruma_common = &ruma_common;
 
-    res.extend(
-        expand_event_enum(kind, V::Full, events, attrs, variants, ruma_common)
-            .unwrap_or_else(syn::Error::into_compile_error),
-    );
     res.extend(expand_content_enum(kind, events, attrs, variants, ruma_common));
 
-    if matches!(kind, EventKind::Ephemeral | EventKind::MessageLike | EventKind::State) {
+    if matches!(kind, EventKind::MessageLike | EventKind::State) {
+        res.extend(
+            expand_event_enum(kind, V::Original, events, attrs, variants, ruma_common)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+        res.extend(
+            expand_event_enum(kind, V::OriginalSync, events, attrs, variants, ruma_common)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+        res.extend(
+            expand_event_enum(kind, V::Redacted, events, attrs, variants, ruma_common)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+        res.extend(
+            expand_event_enum(kind, V::RedactedSync, events, attrs, variants, ruma_common)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+        res.extend(
+            expand_redact(kind, V::Original, variants, ruma_common)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+        res.extend(
+            expand_redact(kind, V::OriginalSync, variants, ruma_common)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+        res.extend(
+            expand_from_full_event(kind, V::Original, variants)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+        res.extend(
+            expand_into_full_event(kind, V::OriginalSync, variants, ruma_common)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+        res.extend(
+            expand_from_full_event(kind, V::Redacted, variants)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+        res.extend(
+            expand_into_full_event(kind, V::RedactedSync, variants, ruma_common)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+    } else {
+        res.extend(
+            expand_event_enum(kind, V::None, events, attrs, variants, ruma_common)
+                .unwrap_or_else(syn::Error::into_compile_error),
+        );
+    }
+
+    if matches!(kind, EventKind::Ephemeral) {
         res.extend(
             expand_event_enum(kind, V::Sync, events, attrs, variants, ruma_common)
                 .unwrap_or_else(syn::Error::into_compile_error),
         );
-        res.extend(
-            expand_from_full_event(kind, V::Full, variants)
-                .unwrap_or_else(syn::Error::into_compile_error),
-        );
-        res.extend(
-            expand_into_full_event(kind, V::Sync, variants, ruma_common)
-                .unwrap_or_else(syn::Error::into_compile_error),
-        );
     }
 
     if matches!(kind, EventKind::State) {
@@ -80,33 +121,6 @@ pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> {
         );
     }
 
-    if matches!(kind, EventKind::MessageLike | EventKind::State) {
-        res.extend(
-            expand_event_enum(kind, V::Redacted, events, attrs, variants, ruma_common)
-                .unwrap_or_else(syn::Error::into_compile_error),
-        );
-        res.extend(
-            expand_event_enum(kind, V::RedactedSync, events, attrs, variants, ruma_common)
-                .unwrap_or_else(syn::Error::into_compile_error),
-        );
-        res.extend(
-            expand_redact(kind, V::Full, variants, ruma_common)
-                .unwrap_or_else(syn::Error::into_compile_error),
-        );
-        res.extend(
-            expand_redact(kind, V::Sync, variants, ruma_common)
-                .unwrap_or_else(syn::Error::into_compile_error),
-        );
-        res.extend(
-            expand_from_full_event(kind, V::Redacted, variants)
-                .unwrap_or_else(syn::Error::into_compile_error),
-        );
-        res.extend(
-            expand_into_full_event(kind, V::RedactedSync, variants, ruma_common)
-                .unwrap_or_else(syn::Error::into_compile_error),
-        );
-    }
-
     Ok(res)
 }
 
@@ -401,7 +415,7 @@ fn expand_redact(
 
             fn redact(
                 self,
-                redaction: #ruma_common::events::room::redaction::SyncRoomRedactionEvent,
+                redaction: #ruma_common::events::room::redaction::OriginalSyncRoomRedactionEvent,
                 version: &#ruma_common::RoomVersionId,
             ) -> #redacted_enum {
                 match self {
@@ -546,7 +560,7 @@ fn to_event_path(
     let path = event_module_path(name);
     let event = m_prefix_name_to_type_name(name).unwrap();
     let event_name = if kind == EventKind::ToDevice {
-        assert_eq!(var, EventKindVariation::Full);
+        assert_eq!(var, EventKindVariation::None);
         format_ident!("ToDevice{}Event", event)
     } else {
         format_ident!("{}{}Event", var, event)

crates/ruma-macros/src/events/event_parse.rs

@@ -19,8 +19,10 @@ mod kw {
 // If the variants of this enum change `to_event_path` needs to be updated as well.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum EventKindVariation {
-    Full,
+    None,
     Sync,
+    Original,
+    OriginalSync,
     Stripped,
     Initial,
     Redacted,
@@ -30,8 +32,10 @@ pub enum EventKindVariation {
 impl fmt::Display for EventKindVariation {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            EventKindVariation::Full => write!(f, ""),
+            EventKindVariation::None => write!(f, ""),
             EventKindVariation::Sync => write!(f, "Sync"),
+            EventKindVariation::Original => write!(f, "Original"),
+            EventKindVariation::OriginalSync => write!(f, "OriginalSync"),
             EventKindVariation::Stripped => write!(f, "Stripped"),
             EventKindVariation::Initial => write!(f, "Initial"),
             EventKindVariation::Redacted => write!(f, "Redacted"),
@@ -46,20 +50,20 @@ impl EventKindVariation {
     }
 
     pub fn is_sync(self) -> bool {
-        matches!(self, Self::Sync | Self::RedactedSync)
+        matches!(self, Self::OriginalSync | Self::RedactedSync)
     }
 
     pub fn to_redacted(self) -> Self {
         match self {
-            EventKindVariation::Full => EventKindVariation::Redacted,
+            EventKindVariation::Original => EventKindVariation::Redacted,
-            EventKindVariation::Sync => EventKindVariation::RedactedSync,
+            EventKindVariation::OriginalSync => EventKindVariation::RedactedSync,
             _ => panic!("No redacted form of {:?}", self),
         }
     }
 
     pub fn to_sync(self) -> Self {
         match self {
-            EventKindVariation::Full => EventKindVariation::Sync,
+            EventKindVariation::Original => EventKindVariation::OriginalSync,
             EventKindVariation::Redacted => EventKindVariation::RedactedSync,
             _ => panic!("No sync form of {:?}", self),
         }
@@ -67,9 +71,9 @@ impl EventKindVariation {
 
     pub fn to_full(self) -> Self {
         match self {
-            EventKindVariation::Sync => EventKindVariation::Full,
+            EventKindVariation::OriginalSync => EventKindVariation::Original,
             EventKindVariation::RedactedSync => EventKindVariation::Redacted,
-            _ => panic!("No full form of {:?}", self),
+            _ => panic!("No original (unredacted) form of {:?}", self),
         }
     }
 }
@@ -127,11 +131,20 @@ impl EventKind {
         use EventKindVariation as V;
 
         match (self, var) {
-            (_, V::Full)
+            (
-            | (Self::MessageLike | Self::RoomRedaction | Self::State | Self::Ephemeral, V::Sync)
+                Self::GlobalAccountData
+                | Self::RoomAccountData
+                | Self::Ephemeral
+                | Self::ToDevice
+                | Self::Presence
+                | Self::HierarchySpaceChild
+                | Self::Decrypted,
+                V::None,
+            )
+            | (Self::Ephemeral, V::Sync)
             | (
                 Self::MessageLike | Self::RoomRedaction | Self::State,
-                V::Redacted | V::RedactedSync,
+                V::Original | V::OriginalSync | V::Redacted | V::RedactedSync,
             )
             | (Self::State, V::Stripped | V::Initial) => Ok(format_ident!("{}{}", var, self)),
             _ => Err(syn::Error::new(
@@ -188,29 +201,33 @@ impl Parse for EventKind {
 pub fn to_kind_variation(ident: &Ident) -> Option<(EventKind, EventKindVariation)> {
     let ident_str = ident.to_string();
     match ident_str.as_str() {
-        "GlobalAccountDataEvent" => Some((EventKind::GlobalAccountData, EventKindVariation::Full)),
+        "GlobalAccountDataEvent" => Some((EventKind::GlobalAccountData, EventKindVariation::None)),
-        "RoomAccountDataEvent" => Some((EventKind::RoomAccountData, EventKindVariation::Full)),
+        "RoomAccountDataEvent" => Some((EventKind::RoomAccountData, EventKindVariation::None)),
-        "EphemeralRoomEvent" => Some((EventKind::Ephemeral, EventKindVariation::Full)),
+        "EphemeralRoomEvent" => Some((EventKind::Ephemeral, EventKindVariation::None)),
         "SyncEphemeralRoomEvent" => Some((EventKind::Ephemeral, EventKindVariation::Sync)),
-        "MessageLikeEvent" => Some((EventKind::MessageLike, EventKindVariation::Full)),
+        "OriginalMessageLikeEvent" => Some((EventKind::MessageLike, EventKindVariation::Original)),
-        "SyncMessageLikeEvent" => Some((EventKind::MessageLike, EventKindVariation::Sync)),
+        "OriginalSyncMessageLikeEvent" => {
+            Some((EventKind::MessageLike, EventKindVariation::OriginalSync))
+        }
         "RedactedMessageLikeEvent" => Some((EventKind::MessageLike, EventKindVariation::Redacted)),
         "RedactedSyncMessageLikeEvent" => {
             Some((EventKind::MessageLike, EventKindVariation::RedactedSync))
         }
-        "StateEvent" => Some((EventKind::State, EventKindVariation::Full)),
+        "OriginalStateEvent" => Some((EventKind::State, EventKindVariation::Original)),
-        "SyncStateEvent" => Some((EventKind::State, EventKindVariation::Sync)),
+        "OriginalSyncStateEvent" => Some((EventKind::State, EventKindVariation::OriginalSync)),
         "StrippedStateEvent" => Some((EventKind::State, EventKindVariation::Stripped)),
         "InitialStateEvent" => Some((EventKind::State, EventKindVariation::Initial)),
         "RedactedStateEvent" => Some((EventKind::State, EventKindVariation::Redacted)),
         "RedactedSyncStateEvent" => Some((EventKind::State, EventKindVariation::RedactedSync)),
-        "ToDeviceEvent" => Some((EventKind::ToDevice, EventKindVariation::Full)),
+        "ToDeviceEvent" => Some((EventKind::ToDevice, EventKindVariation::None)),
-        "PresenceEvent" => Some((EventKind::Presence, EventKindVariation::Full)),
+        "PresenceEvent" => Some((EventKind::Presence, EventKindVariation::None)),
         "HierarchySpaceChildEvent" => {
             Some((EventKind::HierarchySpaceChild, EventKindVariation::Stripped))
         }
-        "RoomRedactionEvent" => Some((EventKind::RoomRedaction, EventKindVariation::Full)),
+        "OriginalRoomRedactionEvent" => Some((EventKind::RoomRedaction, EventKindVariation::None)),
-        "SyncRoomRedactionEvent" => Some((EventKind::RoomRedaction, EventKindVariation::Sync)),
+        "OriginalSyncRoomRedactionEvent" => {
+            Some((EventKind::RoomRedaction, EventKindVariation::OriginalSync))
+        }
         "RedactedRoomRedactionEvent" => {
             Some((EventKind::RoomRedaction, EventKindVariation::Redacted))
         }
@@ -218,7 +235,7 @@ pub fn to_kind_variation(ident: &Ident) -> Option<(EventKind, EventKindVariation
             Some((EventKind::RoomRedaction, EventKindVariation::RedactedSync))
         }
         "DecryptedOlmV1Event" | "DecryptedMegolmV1Event" => {
-            Some((EventKind::Decrypted, EventKindVariation::Full))
+            Some((EventKind::Decrypted, EventKindVariation::None))
         }
         _ => None,
     }

crates/ruma-macros/src/events/util.rs

@@ -4,8 +4,8 @@ pub(crate) fn is_non_stripped_room_event(kind: EventKind, var: EventKindVariatio
     matches!(kind, EventKind::MessageLike | EventKind::State)
         && matches!(
             var,
-            EventKindVariation::Full
+            EventKindVariation::Original
-                | EventKindVariation::Sync
+                | EventKindVariation::OriginalSync
                 | EventKindVariation::Redacted
                 | EventKindVariation::RedactedSync
         )
@@ -13,5 +13,5 @@ pub(crate) fn is_non_stripped_room_event(kind: EventKind, var: EventKindVariatio
 
 pub(crate) fn has_prev_content(kind: EventKind, var: EventKindVariation) -> bool {
     matches!(kind, EventKind::State)
-        && matches!(var, EventKindVariation::Full | EventKindVariation::Sync)
+        && matches!(var, EventKindVariation::Original | EventKindVariation::OriginalSync)
 }

crates/ruma-state-res/README.md

@@ -15,7 +15,7 @@ pub trait Event {
 /// A mapping of event type and state_key to some value `T`, usually an `EventId`.
 pub type StateMap<T> = BTreeMap<(EventType, Option<String>), T>;
 
-/// A mapping of `EventId` to `T`, usually a `StateEvent`.
+/// A mapping of `EventId` to `T`, usually a `OriginalStateEvent`.
 pub type EventMap<T> = BTreeMap<Box<EventId>, T>;
 
 struct StateResolution {

crates/ruma-state-res/benches/state_res_bench.rs

@@ -18,7 +18,7 @@ use std::{
 };
 
 use criterion::{criterion_group, criterion_main, Criterion};
-use event::StateEvent;
+use event::OriginalStateEvent;
 use js_int::{int, uint};
 use maplit::{btreemap, hashmap, hashset};
 use ruma_common::{
@@ -232,7 +232,7 @@ impl<E: Event> TestStore<E> {
     }
 }
 
-impl TestStore<StateEvent> {
+impl TestStore<OriginalStateEvent> {
     #[allow(clippy::type_complexity)]
     fn set_up(
         &mut self,
@@ -372,7 +372,7 @@ fn to_pdu_event<S>(
     content: Box<RawJsonValue>,
     auth_events: &[S],
     prev_events: &[S],
-) -> Arc<StateEvent>
+) -> Arc<OriginalStateEvent>
 where
     S: AsRef<str>,
 {
@@ -384,7 +384,7 @@ where
     let prev_events = prev_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>();
 
     let state_key = state_key.map(ToOwned::to_owned);
-    Arc::new(StateEvent {
+    Arc::new(OriginalStateEvent {
         event_id: id.try_into().unwrap(),
         rest: Pdu::RoomV3Pdu(RoomV3Pdu {
             room_id: room_id().to_owned(),
@@ -406,7 +406,7 @@ where
 
 // all graphs start with these input events
 #[allow(non_snake_case)]
-fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
+fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
     vec![
         to_pdu_event::<&EventId>(
             "CREATE",
@@ -488,7 +488,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
 
 // all graphs start with these input events
 #[allow(non_snake_case)]
-fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
+fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
     vec![
         to_pdu_event(
             "PA",
@@ -541,7 +541,7 @@ mod event {
     use serde::{Deserialize, Serialize};
     use serde_json::value::RawValue as RawJsonValue;
 
-    impl Event for StateEvent {
+    impl Event for OriginalStateEvent {
         type Id = Box<EventId>;
 
         fn event_id(&self) -> &Self::Id {
@@ -631,7 +631,7 @@ mod event {
     }
 
     #[derive(Clone, Debug, Deserialize, Serialize)]
-    pub struct StateEvent {
+    pub struct OriginalStateEvent {
         pub event_id: Box<EventId>,
         #[serde(flatten)]
         pub rest: Pdu,

crates/ruma-state-res/src/event_auth.rs

@@ -982,7 +982,7 @@ mod tests {
         event_auth::valid_membership_change,
         test_utils::{
             alice, charlie, ella, event_id, member_content_ban, member_content_join, room_id,
-            to_pdu_event, StateEvent, INITIAL_EVENTS, INITIAL_EVENTS_CREATE_ROOM,
+            to_pdu_event, OriginalStateEvent, INITIAL_EVENTS, INITIAL_EVENTS_CREATE_ROOM,
         },
         Event, RoomVersion, StateMap,
     };
@@ -1021,7 +1021,7 @@ mod tests {
             &sender,
             fetch_state(RoomEventType::RoomMember, sender.to_string()),
             &requester,
-            None::<StateEvent>,
+            None::<OriginalStateEvent>,
             fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
             fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
             None,
@@ -1065,7 +1065,7 @@ mod tests {
             &sender,
             fetch_state(RoomEventType::RoomMember, sender.to_string()),
             &requester,
-            None::<StateEvent>,
+            None::<OriginalStateEvent>,
             fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
             fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
             None,
@@ -1109,7 +1109,7 @@ mod tests {
             &sender,
             fetch_state(RoomEventType::RoomMember, sender.to_string()),
             &requester,
-            None::<StateEvent>,
+            None::<OriginalStateEvent>,
             fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
             fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
             None,
@@ -1153,7 +1153,7 @@ mod tests {
             &sender,
             fetch_state(RoomEventType::RoomMember, sender.to_string()),
             &requester,
-            None::<StateEvent>,
+            None::<OriginalStateEvent>,
             fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
             fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
             None,
@@ -1214,7 +1214,7 @@ mod tests {
             &sender,
             fetch_state(RoomEventType::RoomMember, sender.to_string()),
             &requester,
-            None::<StateEvent>,
+            None::<OriginalStateEvent>,
             fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
             fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
             Some(&alice()),
@@ -1230,7 +1230,7 @@ mod tests {
             &sender,
             fetch_state(RoomEventType::RoomMember, sender.to_string()),
             &requester,
-            None::<StateEvent>,
+            None::<OriginalStateEvent>,
             fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
             fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
             Some(&ella()),
@@ -1283,7 +1283,7 @@ mod tests {
             &sender,
             fetch_state(RoomEventType::RoomMember, sender.to_string()),
             &requester,
-            None::<StateEvent>,
+            None::<OriginalStateEvent>,
             fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
             fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
             None,

crates/ruma-state-res/src/lib.rs

@@ -657,7 +657,8 @@ mod tests {
         room_version::RoomVersion,
         test_utils::{
             alice, bob, charlie, do_check, ella, event_id, member_content_ban, member_content_join,
-            room_id, to_init_pdu_event, to_pdu_event, zara, StateEvent, TestStore, INITIAL_EVENTS,
+            room_id, to_init_pdu_event, to_pdu_event, zara, OriginalStateEvent, TestStore,
+            INITIAL_EVENTS,
         },
         Event, StateMap,
     };
@@ -1042,7 +1043,7 @@ mod tests {
         let _ =
             tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
 
-        let mut store = TestStore::<StateEvent>(hashmap! {});
+        let mut store = TestStore::<OriginalStateEvent>(hashmap! {});
 
         // build up the DAG
         let (state_at_bob, state_at_charlie, expected) = store.set_up();
@@ -1208,7 +1209,7 @@ mod tests {
     }
 
     #[allow(non_snake_case)]
-    fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
+    fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
         vec![
             to_pdu_event(
                 "PA",
@@ -1253,7 +1254,7 @@ mod tests {
     }
 
     #[allow(non_snake_case)]
-    fn JOIN_RULE() -> HashMap<Box<EventId>, Arc<StateEvent>> {
+    fn JOIN_RULE() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
         vec![
             to_pdu_event(
                 "JR",

crates/ruma-state-res/src/test_utils.rs

@@ -29,12 +29,12 @@ use tracing::info;
 
 use crate::{auth_types_for_event, Error, Event, Result, StateMap};
 
-pub use event::StateEvent;
+pub use event::OriginalStateEvent;
 
 static SERVER_TIMESTAMP: AtomicU64 = AtomicU64::new(0);
 
 pub fn do_check(
-    events: &[Arc<StateEvent>],
+    events: &[Arc<OriginalStateEvent>],
     edges: Vec<Vec<Box<EventId>>>,
     expected_state_ids: Vec<Box<EventId>>,
 ) {
@@ -52,7 +52,7 @@ pub fn do_check(
 
     // This will be lexi_topo_sorted for resolution
     let mut graph = HashMap::new();
-    // This is the same as in `resolve` event_id -> StateEvent
+    // This is the same as in `resolve` event_id -> OriginalStateEvent
     let mut fake_event_map = HashMap::new();
 
     // Create the DB of events that led up to this point
@@ -76,8 +76,8 @@ pub fn do_check(
         }
     }
 
-    // event_id -> StateEvent
+    // event_id -> OriginalStateEvent
-    let mut event_map: HashMap<Box<EventId>, Arc<StateEvent>> = HashMap::new();
+    let mut event_map: HashMap<Box<EventId>, Arc<OriginalStateEvent>> = HashMap::new();
     // event_id -> StateMap<Box<EventId>>
     let mut state_at_event: HashMap<Box<EventId>, StateMap<Box<EventId>>> = HashMap::new();
 
@@ -245,7 +245,7 @@ impl<E: Event> TestStore<E> {
 
 // A StateStore implementation for testing
 #[allow(clippy::type_complexity)]
-impl TestStore<StateEvent> {
+impl TestStore<OriginalStateEvent> {
     pub fn set_up(
         &mut self,
     ) -> (StateMap<Box<EventId>>, StateMap<Box<EventId>>, StateMap<Box<EventId>>) {
@@ -387,12 +387,12 @@ pub fn to_init_pdu_event(
     ev_type: RoomEventType,
     state_key: Option<&str>,
     content: Box<RawJsonValue>,
-) -> Arc<StateEvent> {
+) -> Arc<OriginalStateEvent> {
     let ts = SERVER_TIMESTAMP.fetch_add(1, SeqCst);
     let id = if id.contains('$') { id.to_owned() } else { format!("${}:foo", id) };
 
     let state_key = state_key.map(ToOwned::to_owned);
-    Arc::new(StateEvent {
+    Arc::new(OriginalStateEvent {
         event_id: id.try_into().unwrap(),
         rest: Pdu::RoomV3Pdu(RoomV3Pdu {
             room_id: room_id().to_owned(),
@@ -420,7 +420,7 @@ pub fn to_pdu_event<S>(
     content: Box<RawJsonValue>,
     auth_events: &[S],
     prev_events: &[S],
-) -> Arc<StateEvent>
+) -> Arc<OriginalStateEvent>
 where
     S: AsRef<str>,
 {
@@ -430,7 +430,7 @@ where
     let prev_events = prev_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>();
 
     let state_key = state_key.map(ToOwned::to_owned);
-    Arc::new(StateEvent {
+    Arc::new(OriginalStateEvent {
         event_id: id.try_into().unwrap(),
         rest: Pdu::RoomV3Pdu(RoomV3Pdu {
             room_id: room_id().to_owned(),
@@ -452,7 +452,7 @@ where
 
 // all graphs start with these input events
 #[allow(non_snake_case)]
-pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
+pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
     vec![
         to_pdu_event::<&EventId>(
             "CREATE",
@@ -534,7 +534,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
 
 // all graphs start with these input events
 #[allow(non_snake_case)]
-pub fn INITIAL_EVENTS_CREATE_ROOM() -> HashMap<Box<EventId>, Arc<StateEvent>> {
+pub fn INITIAL_EVENTS_CREATE_ROOM() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
     vec![to_pdu_event::<&EventId>(
         "CREATE",
         alice(),
@@ -567,7 +567,7 @@ pub mod event {
 
     use crate::Event;
 
-    impl Event for StateEvent {
+    impl Event for OriginalStateEvent {
         type Id = Box<EventId>;
 
         fn event_id(&self) -> &Self::Id {
@@ -658,13 +658,13 @@ pub mod event {
 
     #[derive(Clone, Debug, Deserialize, Serialize)]
     #[allow(clippy::exhaustive_structs)]
-    pub struct StateEvent {
+    pub struct OriginalStateEvent {
         pub event_id: Box<EventId>,
         #[serde(flatten)]
         pub rest: Pdu,
     }
 
-    //impl StateEvent {
+    //impl OriginalStateEvent {
     //    pub fn state_key(&self) -> &str {
     //        match &self.rest {
     //            Pdu::RoomV1Pdu(ev) => ev.state_key.as_ref().unwrap(),

examples/joke_bot/src/main.rs

@@ -9,7 +9,7 @@ use ruma::{
     assign, client,
     events::{
         room::message::{MessageType, RoomMessageEventContent},
-        AnySyncMessageLikeEvent, AnySyncRoomEvent,
+        AnyOriginalSyncMessageLikeEvent, AnySyncRoomEvent,
     },
     presence::PresenceState,
     serde::Raw,
@@ -146,8 +146,9 @@ async fn handle_message(
     room_id: &RoomId,
     bot_user_id: &UserId,
 ) -> Result<(), Box<dyn Error>> {
-    if let Ok(AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(m))) =
+    if let Ok(AnySyncRoomEvent::OriginalMessageLike(
-        e.deserialize()
+        AnyOriginalSyncMessageLikeEvent::RoomMessage(m),
+    )) = e.deserialize()
     {
         // workaround because Conduit does not implement filtering.
         if m.sender == bot_user_id {

examples/message_log/src/main.rs

@@ -5,7 +5,7 @@ use ruma::{
     api::client::{filter::FilterDefinition, sync::sync_events},
     events::{
         room::message::{MessageType, RoomMessageEventContent, TextMessageEventContent},
-        AnySyncMessageLikeEvent, AnySyncRoomEvent, SyncMessageLikeEvent,
+        AnyOriginalSyncMessageLikeEvent, AnySyncRoomEvent, OriginalSyncMessageLikeEvent,
     },
     presence::PresenceState,
 };
@@ -42,8 +42,8 @@ async fn log_messages(
         for (room_id, room) in res.rooms.join {
             for event in room.timeline.events.into_iter().flat_map(|r| r.deserialize()) {
                 // Filter out the text messages
-                if let AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
+                if let AnySyncRoomEvent::OriginalMessageLike(
-                    SyncMessageLikeEvent {
+                    AnyOriginalSyncMessageLikeEvent::RoomMessage(OriginalSyncMessageLikeEvent {
                         content:
                             RoomMessageEventContent {
                                 msgtype:
@@ -54,8 +54,8 @@ async fn log_messages(
                             },
                         sender,
                         ..
-                    },
+                    }),
-                )) = event
+                ) = event
                 {
                     println!("{:?} in {:?}: {}", sender, room_id, msg_body);
                 }