events: Rename Any[Sync]RoomEvent to Any[Sync]TimelineEvent

crates/ruma-appservice-api/src/event/push_events.rs

@@ -8,7 +8,7 @@ pub mod v1 {
     //! [spec]: https://spec.matrix.org/v1.2/application-service-api/#put_matrixappv1transactionstxnid
 
     use ruma_common::{
-        api::ruma_api, events::AnyRoomEvent, serde::Raw, OwnedTransactionId, TransactionId,
+        api::ruma_api, events::AnyTimelineEvent, serde::Raw, OwnedTransactionId, TransactionId,
     };
 
     ruma_api! {
@@ -30,7 +30,7 @@ pub mod v1 {
             pub txn_id: &'a TransactionId,
 
             /// A list of events.
-            pub events: &'a [Raw<AnyRoomEvent>],
+            pub events: &'a [Raw<AnyTimelineEvent>],
         }
 
         #[derive(Default)]
@@ -39,14 +39,17 @@ pub mod v1 {
 
     impl<'a> Request<'a> {
         /// Creates a new `Request` with the given transaction ID and list of events.
-        pub fn new(txn_id: &'a TransactionId, events: &'a [Raw<AnyRoomEvent>]) -> Self {
+        pub fn new(txn_id: &'a TransactionId, events: &'a [Raw<AnyTimelineEvent>]) -> Self {
             Self { txn_id, events }
         }
     }
 
     impl IncomingRequest {
         /// Creates an `IncomingRequest` with the given transaction ID and list of events.
-        pub fn new(txn_id: OwnedTransactionId, events: Vec<Raw<AnyRoomEvent>>) -> IncomingRequest {
+        pub fn new(
+            txn_id: OwnedTransactionId,
+            events: Vec<Raw<AnyTimelineEvent>>,
+        ) -> IncomingRequest {
             IncomingRequest { txn_id, events }
         }
     }

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::{AnyStateEvent, AnyTimelineEvent},
         serde::Raw,
         EventId, RoomId,
     };
@@ -66,16 +66,16 @@ pub mod v3 {
             /// A list of room events that happened just before the requested event,
             /// in reverse-chronological order.
             #[serde(default, skip_serializing_if = "Vec::is_empty")]
-            pub events_before: Vec<Raw<AnyRoomEvent>>,
+            pub events_before: Vec<Raw<AnyTimelineEvent>>,
 
             /// Details of the requested event.
             #[serde(skip_serializing_if = "Option::is_none")]
-            pub event: Option<Raw<AnyRoomEvent>>,
+            pub event: Option<Raw<AnyTimelineEvent>>,
 
             /// A list of room events that happened just after the requested event,
             /// in chronological order.
             #[serde(default, skip_serializing_if = "Vec::is_empty")]
-            pub events_after: Vec<Raw<AnyRoomEvent>>,
+            pub events_after: Vec<Raw<AnyTimelineEvent>>,
 
             /// The state of the room at the last event returned.
             #[serde(default, skip_serializing_if = "Vec::is_empty")]

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::{AnyStateEvent, AnyTimelineEvent},
         serde::Raw,
         RoomId,
     };
@@ -85,7 +85,7 @@ pub mod v3 {
 
             /// A list of room events.
             #[serde(default)]
-            pub chunk: Vec<Raw<AnyRoomEvent>>,
+            pub chunk: Vec<Raw<AnyTimelineEvent>>,
 
             /// A list of state events relevant to showing the `chunk`.
             #[serde(default, skip_serializing_if = "Vec::is_empty")]

crates/ruma-client-api/src/push/get_notifications.rs

@@ -7,7 +7,7 @@ pub mod v3 {
 
     use js_int::UInt;
     use ruma_common::{
-        api::ruma_api, events::AnySyncRoomEvent, push::Action, serde::Raw,
+        api::ruma_api, events::AnySyncTimelineEvent, push::Action, serde::Raw,
         MilliSecondsSinceUnixEpoch, OwnedRoomId,
     };
     use serde::{Deserialize, Serialize};
@@ -83,7 +83,7 @@ pub mod v3 {
         pub actions: Vec<Action>,
 
         /// The event that triggered the notification.
-        pub event: Raw<AnySyncRoomEvent>,
+        pub event: Raw<AnySyncTimelineEvent>,
 
         /// The profile tag of the rule that matched this event.
         #[serde(skip_serializing_if = "Option::is_none")]
@@ -105,7 +105,7 @@ pub mod v3 {
         /// timestamp.
         pub fn new(
             actions: Vec<Action>,
-            event: Raw<AnySyncRoomEvent>,
+            event: Raw<AnySyncTimelineEvent>,
             read: bool,
             room_id: OwnedRoomId,
             ts: MilliSecondsSinceUnixEpoch,

crates/ruma-client-api/src/room/get_room_event.rs

@@ -5,7 +5,7 @@ pub mod v3 {
     //!
     //! [spec]: https://spec.matrix.org/v1.2/client-server-api/#get_matrixclientv3roomsroomideventeventid
 
-    use ruma_common::{api::ruma_api, events::AnyRoomEvent, serde::Raw, EventId, RoomId};
+    use ruma_common::{api::ruma_api, events::AnyTimelineEvent, serde::Raw, EventId, RoomId};
 
     ruma_api! {
         metadata: {
@@ -32,7 +32,7 @@ pub mod v3 {
         response: {
             /// Arbitrary JSON of the event body.
             #[ruma_api(body)]
-            pub event: Raw<AnyRoomEvent>,
+            pub event: Raw<AnyTimelineEvent>,
         }
 
         error: crate::Error
@@ -47,7 +47,7 @@ pub mod v3 {
 
     impl Response {
         /// Creates a new `Response` with the given event.
-        pub fn new(event: Raw<AnyRoomEvent>) -> Self {
+        pub fn new(event: Raw<AnyTimelineEvent>) -> Self {
             Self { event }
         }
     }

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::{AnyStateEvent, AnyTimelineEvent},
         serde::{Incoming, Raw, StringEnum},
         OwnedEventId, OwnedMxcUri, OwnedRoomId, OwnedUserId,
     };
@@ -198,11 +198,11 @@ pub mod v3 {
 
         /// Events just after the result.
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
-        pub events_after: Vec<Raw<AnyRoomEvent>>,
+        pub events_after: Vec<Raw<AnyTimelineEvent>>,
 
         /// Events just before the result.
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
-        pub events_before: Vec<Raw<AnyRoomEvent>>,
+        pub events_before: Vec<Raw<AnyTimelineEvent>>,
 
         /// The historic profile information of the users that sent the events returned.
         #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
@@ -441,7 +441,7 @@ pub mod v3 {
 
         /// The event that matched.
         #[serde(skip_serializing_if = "Option::is_none")]
-        pub result: Option<Raw<AnyRoomEvent>>,
+        pub result: Option<Raw<AnyTimelineEvent>>,
     }
 
     impl SearchResult {

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

@@ -10,7 +10,7 @@ use ruma_common::{
     api::ruma_api,
     events::{
         presence::PresenceEvent, AnyGlobalAccountDataEvent, AnyRoomAccountDataEvent,
-        AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnySyncRoomEvent, AnySyncStateEvent,
+        AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnySyncStateEvent, AnySyncTimelineEvent,
         AnyToDeviceEvent,
     },
     presence::PresenceState,
@@ -336,7 +336,7 @@ pub struct Timeline {
 
     /// A list of events.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub events: Vec<Raw<AnySyncRoomEvent>>,
+    pub events: Vec<Raw<AnySyncTimelineEvent>>,
 }
 
 impl Timeline {

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

@@ -6,7 +6,7 @@ use super::UnreadNotificationsCount;
 use js_int::UInt;
 use ruma_common::{
     api::ruma_api,
-    events::{AnyStrippedStateEvent, AnySyncRoomEvent, AnySyncStateEvent, RoomEventType},
+    events::{AnyStrippedStateEvent, AnySyncStateEvent, AnySyncTimelineEvent, RoomEventType},
     serde::{duration::opt_ms, Raw},
     OwnedRoomId,
 };
@@ -315,7 +315,7 @@ pub struct SlidingSyncRoom {
 
     /// The timeline of messages and state changes in the room.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub timeline: Vec<Raw<AnySyncRoomEvent>>,
+    pub timeline: Vec<Raw<AnySyncTimelineEvent>>,
 
     /// Updates to the state at the beginning of the `timeline`.
     /// A list of state events.

crates/ruma-common/CHANGELOG.md

@@ -27,6 +27,7 @@ Breaking changes:
 * Allow to add routing servers to `RoomId::matrix_to_event_uri()`
 * Move `receipt::ReceiptType` to `events::receipt`
 * Make `Clone` as supertrait of `api::OutgoingRequest`
+* Rename `Any[Sync]RoomEvent` to `Any[Sync]TimelineEvent`
 
 [spec]: https://github.com/matrix-org/matrix-spec-proposals/pull/3669
 

crates/ruma-common/benches/event_deserialize.rs

@@ -10,7 +10,7 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use ruma_common::{
     events::{
-        room::power_levels::RoomPowerLevelsEventContent, AnyRoomEvent, AnyStateEvent,
+        room::power_levels::RoomPowerLevelsEventContent, AnyStateEvent, AnyTimelineEvent,
         OriginalStateEvent,
     },
     serde::Raw,
@@ -53,9 +53,9 @@ fn power_levels() -> serde_json::Value {
 fn deserialize_any_room_event(c: &mut Criterion) {
     let json_data = power_levels();
 
-    c.bench_function("deserialize to `AnyRoomEvent`", |b| {
+    c.bench_function("deserialize to `AnyTimelineEvent`", |b| {
         b.iter(|| {
-            let _ = serde_json::from_value::<AnyRoomEvent>(json_data.clone()).unwrap();
+            let _ = serde_json::from_value::<AnyTimelineEvent>(json_data.clone()).unwrap();
         })
     });
 }

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

@@ -158,7 +158,7 @@ macro_rules! room_ev_accessor {
 /// Any room event.
 #[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
 #[derive(Clone, Debug, EventEnumFromEvent)]
-pub enum AnyRoomEvent {
+pub enum AnyTimelineEvent {
     /// Any message-like event.
     MessageLike(AnyMessageLikeEvent),
 
@@ -166,7 +166,7 @@ pub enum AnyRoomEvent {
     State(AnyStateEvent),
 }
 
-impl AnyRoomEvent {
+impl AnyTimelineEvent {
     room_ev_accessor!(origin_server_ts: MilliSecondsSinceUnixEpoch);
     room_ev_accessor!(room_id: &RoomId);
     room_ev_accessor!(event_id: &EventId);
@@ -186,7 +186,7 @@ impl AnyRoomEvent {
 /// Sync room events are room event without a `room_id`, as returned in `/sync` responses.
 #[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
 #[derive(Clone, Debug, EventEnumFromEvent)]
-pub enum AnySyncRoomEvent {
+pub enum AnySyncTimelineEvent {
     /// Any sync message-like event.
     MessageLike(AnySyncMessageLikeEvent),
 
@@ -194,7 +194,7 @@ pub enum AnySyncRoomEvent {
     State(AnySyncStateEvent),
 }
 
-impl AnySyncRoomEvent {
+impl AnySyncTimelineEvent {
     room_ev_accessor!(origin_server_ts: MilliSecondsSinceUnixEpoch);
     room_ev_accessor!(event_id: &EventId);
     room_ev_accessor!(sender: &UserId);
@@ -207,11 +207,11 @@ impl AnySyncRoomEvent {
         }
     }
 
-    /// Converts `self` to an `AnyRoomEvent` by adding the given a room ID.
+    /// Converts `self` to an `AnyTimelineEvent` by adding the given a room ID.
-    pub fn into_full_event(self, room_id: OwnedRoomId) -> AnyRoomEvent {
+    pub fn into_full_event(self, room_id: OwnedRoomId) -> AnyTimelineEvent {
         match self {
-            Self::MessageLike(ev) => AnyRoomEvent::MessageLike(ev.into_full_event(room_id)),
+            Self::MessageLike(ev) => AnyTimelineEvent::MessageLike(ev.into_full_event(room_id)),
-            Self::State(ev) => AnyRoomEvent::State(ev.into_full_event(room_id)),
+            Self::State(ev) => AnyTimelineEvent::State(ev.into_full_event(room_id)),
         }
     }
 }
@@ -222,7 +222,7 @@ struct EventDeHelper {
     pub state_key: Option<de::IgnoredAny>,
 }
 
-impl<'de> Deserialize<'de> for AnyRoomEvent {
+impl<'de> Deserialize<'de> for AnyTimelineEvent {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: de::Deserializer<'de>,
@@ -231,14 +231,14 @@ impl<'de> Deserialize<'de> for AnyRoomEvent {
         let EventDeHelper { state_key } = from_raw_json_value(&json)?;
 
         if state_key.is_some() {
-            Ok(AnyRoomEvent::State(from_raw_json_value(&json)?))
+            Ok(AnyTimelineEvent::State(from_raw_json_value(&json)?))
         } else {
-            Ok(AnyRoomEvent::MessageLike(from_raw_json_value(&json)?))
+            Ok(AnyTimelineEvent::MessageLike(from_raw_json_value(&json)?))
         }
     }
 }
 
-impl<'de> Deserialize<'de> for AnySyncRoomEvent {
+impl<'de> Deserialize<'de> for AnySyncTimelineEvent {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: de::Deserializer<'de>,
@@ -247,14 +247,14 @@ impl<'de> Deserialize<'de> for AnySyncRoomEvent {
         let EventDeHelper { state_key } = from_raw_json_value(&json)?;
 
         if state_key.is_some() {
-            Ok(AnySyncRoomEvent::State(from_raw_json_value(&json)?))
+            Ok(AnySyncTimelineEvent::State(from_raw_json_value(&json)?))
         } else {
-            Ok(AnySyncRoomEvent::MessageLike(from_raw_json_value(&json)?))
+            Ok(AnySyncTimelineEvent::MessageLike(from_raw_json_value(&json)?))
         }
     }
 }
 
-impl Redact for AnyRoomEvent {
+impl Redact for AnyTimelineEvent {
     type Redacted = Self;
 
     /// Redacts `self`, referencing the given event in `unsigned.redacted_because`.
@@ -268,7 +268,7 @@ impl Redact for AnyRoomEvent {
     }
 }
 
-impl Redact for AnySyncRoomEvent {
+impl Redact for AnySyncTimelineEvent {
     type Redacted = Self;
 
     /// Redacts `self`, referencing the given event in `unsigned.redacted_because`.

crates/ruma-common/src/serde/raw.rs

@@ -25,14 +25,14 @@ use serde_json::value::{to_raw_value as to_raw_json_value, RawValue as RawJsonVa
 /// # use serde::Deserialize;
 /// # use ruma_common::serde::Raw;
 /// # #[derive(Deserialize)]
-/// # struct AnyRoomEvent;
+/// # struct AnyTimelineEvent;
 ///
 /// let json = r#"{ "type": "imagine a full event", "content": {...} }"#;
 ///
-/// let deser = serde_json::from_str::<Raw<AnyRoomEvent>>(json)
+/// let deser = serde_json::from_str::<Raw<AnyTimelineEvent>>(json)
 ///     .unwrap() // the first Result from serde_json::from_str, will not fail
 ///     .deserialize() // deserialize to the inner type
-///     .unwrap(); // finally get to the AnyRoomEvent
+///     .unwrap(); // finally get to the AnyTimelineEvent
 /// ```
 #[repr(transparent)]
 pub struct Raw<T> {

crates/ruma-common/tests/api/ruma_api_macros.rs

@@ -3,7 +3,7 @@
 pub mod some_endpoint {
     use ruma_common::{
         api::ruma_api,
-        events::{tag::TagEvent, AnyRoomEvent},
+        events::{tag::TagEvent, AnyTimelineEvent},
         serde::Raw,
         OwnedUserId,
     };
@@ -52,7 +52,7 @@ pub mod some_endpoint {
             pub event: Raw<TagEvent>,
 
             // ... and to allow unknown events when the endpoint deals with event collections.
-            pub list_of_events: Vec<Raw<AnyRoomEvent>>,
+            pub list_of_events: Vec<Raw<AnyTimelineEvent>>,
         }
     }
 }

crates/ruma-common/tests/api/ui/01-api-sanity-check.rs

@@ -1,6 +1,6 @@
 use ruma_common::{
     api::ruma_api,
-    events::{tag::TagEvent, AnyRoomEvent},
+    events::{tag::TagEvent, AnyTimelineEvent},
     serde::Raw,
 };
 
@@ -53,7 +53,7 @@ ruma_api! {
         pub event: Raw<TagEvent>,
 
         // ... and to allow unknown events when the endpoint deals with event collections.
-        pub list_of_events: Vec<Raw<AnyRoomEvent>>,
+        pub list_of_events: Vec<Raw<AnyTimelineEvent>>,
     }
 }
 

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

@@ -16,8 +16,8 @@ use ruma_common::{
             message::{MessageType, RoomMessageEventContent},
             power_levels::RoomPowerLevelsEventContent,
         },
-        AnyEphemeralRoomEvent, AnyMessageLikeEvent, AnyRoomEvent, AnyStateEvent,
+        AnyEphemeralRoomEvent, AnyMessageLikeEvent, AnyStateEvent, AnySyncMessageLikeEvent,
-        AnySyncMessageLikeEvent, AnySyncRoomEvent, AnySyncStateEvent, EphemeralRoomEventType,
+        AnySyncStateEvent, AnySyncTimelineEvent, AnyTimelineEvent, EphemeralRoomEventType,
         GlobalAccountDataEventType, MessageLikeEventType, MessageLikeUnsigned,
         OriginalMessageLikeEvent, OriginalStateEvent, OriginalSyncMessageLikeEvent,
         OriginalSyncStateEvent, RoomAccountDataEventType, StateEventType, ToDeviceEventType,
@@ -128,8 +128,8 @@ fn power_event_sync_deserialization() {
     });
 
     let ban = assert_matches!(
-        from_json_value::<AnySyncRoomEvent>(json_data),
+        from_json_value::<AnySyncTimelineEvent>(json_data),
-        Ok(AnySyncRoomEvent::State(
+        Ok(AnySyncTimelineEvent::State(
             AnySyncStateEvent::RoomPowerLevels(SyncStateEvent::Original(
                 OriginalSyncStateEvent {
                     content: RoomPowerLevelsEventContent {
@@ -148,8 +148,8 @@ fn message_event_sync_deserialization() {
     let json_data = message_event_sync();
 
     let text_content = assert_matches!(
-        from_json_value::<AnySyncRoomEvent>(json_data),
+        from_json_value::<AnySyncTimelineEvent>(json_data),
-        Ok(AnySyncRoomEvent::MessageLike(
+        Ok(AnySyncTimelineEvent::MessageLike(
             AnySyncMessageLikeEvent::RoomMessage(SyncMessageLikeEvent::Original(
                 OriginalSyncMessageLikeEvent {
                     content: RoomMessageEventContent {
@@ -171,8 +171,8 @@ fn aliases_event_sync_deserialization() {
     let json_data = aliases_event_sync();
 
     let ev = assert_matches!(
-        from_json_value::<AnySyncRoomEvent>(json_data),
+        from_json_value::<AnySyncTimelineEvent>(json_data),
-        Ok(AnySyncRoomEvent::State(AnySyncStateEvent::RoomAliases(SyncStateEvent::Original(
+        Ok(AnySyncTimelineEvent::State(AnySyncStateEvent::RoomAliases(SyncStateEvent::Original(
             ev,
         )))) => ev
     );
@@ -185,8 +185,8 @@ fn message_room_event_deserialization() {
     let json_data = message_event();
 
     let text_content = assert_matches!(
-        from_json_value::<AnyRoomEvent>(json_data),
+        from_json_value::<AnyTimelineEvent>(json_data),
-        Ok(AnyRoomEvent::MessageLike(
+        Ok(AnyTimelineEvent::MessageLike(
             AnyMessageLikeEvent::RoomMessage(MessageLikeEvent::Original(
                 OriginalMessageLikeEvent {
                     content: RoomMessageEventContent {
@@ -232,8 +232,8 @@ fn alias_room_event_deserialization() {
     let json_data = aliases_event();
 
     let aliases = assert_matches!(
-        from_json_value::<AnyRoomEvent>(json_data),
+        from_json_value::<AnyTimelineEvent>(json_data),
-        Ok(AnyRoomEvent::State(
+        Ok(AnyTimelineEvent::State(
             AnyStateEvent::RoomAliases(StateEvent::Original(OriginalStateEvent {
                 content: RoomAliasesEventContent {
                     aliases,
@@ -251,8 +251,8 @@ fn message_event_deserialization() {
     let json_data = message_event();
 
     let text_content = assert_matches!(
-        from_json_value::<AnyRoomEvent>(json_data),
+        from_json_value::<AnyTimelineEvent>(json_data),
-        Ok(AnyRoomEvent::MessageLike(
+        Ok(AnyTimelineEvent::MessageLike(
             AnyMessageLikeEvent::RoomMessage(MessageLikeEvent::Original(OriginalMessageLikeEvent {
                 content: RoomMessageEventContent {
                     msgtype: MessageType::Text(text_content),
@@ -272,8 +272,8 @@ fn alias_event_deserialization() {
     let json_data = aliases_event();
 
     let aliases = assert_matches!(
-        from_json_value::<AnyRoomEvent>(json_data),
+        from_json_value::<AnyTimelineEvent>(json_data),
-        Ok(AnyRoomEvent::State(
+        Ok(AnyTimelineEvent::State(
             AnyStateEvent::RoomAliases(StateEvent::Original(OriginalStateEvent {
                 content: RoomAliasesEventContent {
                     aliases,
@@ -291,8 +291,8 @@ fn alias_event_field_access() {
     let json_data = aliases_event();
 
     let state_event = assert_matches!(
-        from_json_value::<AnyRoomEvent>(json_data.clone()),
+        from_json_value::<AnyTimelineEvent>(json_data.clone()),
-        Ok(AnyRoomEvent::State(state_event)) => state_event
+        Ok(AnyTimelineEvent::State(state_event)) => state_event
     );
     assert_eq!(state_event.state_key(), "room.com");
     assert_eq!(state_event.room_id(), "!room:room.com");

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

@@ -11,8 +11,8 @@ use ruma_common::{
                 OriginalSyncRoomRedactionEvent, RoomRedactionEventContent, SyncRoomRedactionEvent,
             },
         },
-        AnyMessageLikeEvent, AnyRoomEvent, AnySyncMessageLikeEvent, AnySyncRoomEvent,
+        AnyMessageLikeEvent, AnySyncMessageLikeEvent, AnySyncStateEvent, AnySyncTimelineEvent,
-        AnySyncStateEvent, EventContent, MessageLikeEvent, MessageLikeUnsigned, RedactContent,
+        AnyTimelineEvent, EventContent, MessageLikeEvent, MessageLikeUnsigned, RedactContent,
         RedactedSyncMessageLikeEvent, RedactedSyncStateEvent, RedactedUnsigned,
         SyncMessageLikeEvent, SyncStateEvent,
     },
@@ -122,8 +122,8 @@ fn redacted_aliases_deserialize() {
     let actual = to_json_value(&redacted).unwrap();
 
     let redacted = assert_matches!(
-        from_json_value::<AnySyncRoomEvent>(actual),
+        from_json_value::<AnySyncTimelineEvent>(actual),
-        Ok(AnySyncRoomEvent::State(AnySyncStateEvent::RoomAliases(
+        Ok(AnySyncTimelineEvent::State(AnySyncStateEvent::RoomAliases(
             SyncStateEvent::Redacted(redacted),
         ))) => redacted
     );
@@ -145,8 +145,8 @@ fn redacted_deserialize_any_room() {
     let actual = to_json_value(&redacted).unwrap();
 
     let redacted = assert_matches!(
-        from_json_value::<AnyRoomEvent>(actual),
+        from_json_value::<AnyTimelineEvent>(actual),
-        Ok(AnyRoomEvent::MessageLike(AnyMessageLikeEvent::RoomMessage(
+        Ok(AnyTimelineEvent::MessageLike(AnyMessageLikeEvent::RoomMessage(
             MessageLikeEvent::Redacted(redacted),
         ))) => redacted
     );
@@ -157,8 +157,8 @@ fn redacted_deserialize_any_room() {
 #[test]
 fn redacted_deserialize_any_room_sync() {
     let mut unsigned = RedactedUnsigned::default();
-    // The presence of `redacted_because` triggers the event enum (AnySyncRoomEvent in this case)
+    // The presence of `redacted_because` triggers the event enum (AnySyncTimelineEvent in this
-    // to return early with `RedactedContent` instead of failing to deserialize according
+    // case) to return early with `RedactedContent` instead of failing to deserialize according
     // to the event type string.
     unsigned.redacted_because =
         Some(Box::new(SyncRoomRedactionEvent::Original(OriginalSyncRoomRedactionEvent {
@@ -181,8 +181,8 @@ fn redacted_deserialize_any_room_sync() {
     let actual = to_json_value(&redacted).unwrap();
 
     let redacted = assert_matches!(
-        from_json_value::<AnySyncRoomEvent>(actual),
+        from_json_value::<AnySyncTimelineEvent>(actual),
-        Ok(AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
+        Ok(AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
             SyncMessageLikeEvent::Redacted(redacted),
         ))) => redacted
     );
@@ -204,8 +204,8 @@ fn redacted_state_event_deserialize() {
     });
 
     let redacted = assert_matches!(
-        from_json_value::<AnySyncRoomEvent>(redacted),
+        from_json_value::<AnySyncTimelineEvent>(redacted),
-        Ok(AnySyncRoomEvent::State(AnySyncStateEvent::RoomCreate(
+        Ok(AnySyncTimelineEvent::State(AnySyncStateEvent::RoomCreate(
             SyncStateEvent::Redacted(redacted),
         ))) => redacted
     );
@@ -226,8 +226,8 @@ fn redacted_custom_event_deserialize() {
     });
 
     let state_ev = assert_matches!(
-        from_json_value::<AnySyncRoomEvent>(redacted),
+        from_json_value::<AnySyncTimelineEvent>(redacted),
-        Ok(AnySyncRoomEvent::State(state_ev)) => state_ev
+        Ok(AnySyncTimelineEvent::State(state_ev)) => state_ev
     );
     assert_eq!(state_ev.event_id(), "$h29iv0s8:example.com");
 }

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

@@ -4,9 +4,9 @@ use js_int::uint;
 use ruma_common::{
     event_id,
     events::{
-        room::aliases::RoomAliasesEventContent, AnyRoomEvent, AnyStateEvent, AnyStateEventContent,
+        room::aliases::RoomAliasesEventContent, AnyStateEvent, AnyStateEventContent,
-        AnySyncStateEvent, OriginalStateEvent, StateEvent, StateEventType, StateUnsigned,
+        AnySyncStateEvent, AnyTimelineEvent, OriginalStateEvent, StateEvent, StateEventType,
-        SyncStateEvent,
+        StateUnsigned, SyncStateEvent,
     },
     mxc_uri, room_alias_id, room_id,
     serde::Raw,
@@ -214,8 +214,8 @@ fn deserialize_member_event_with_top_level_membership_field() {
     });
 
     let ev = assert_matches!(
-        from_json_value::<AnyRoomEvent>(json_data),
+        from_json_value::<AnyTimelineEvent>(json_data),
-        Ok(AnyRoomEvent::State(AnyStateEvent::RoomMember(StateEvent::Original(ev)))) => ev
+        Ok(AnyTimelineEvent::State(AnyStateEvent::RoomMember(StateEvent::Original(ev)))) => ev
     );
     assert_eq!(ev.event_id, "$h29iv0s8:example.com");
     assert_eq!(ev.origin_server_ts, MilliSecondsSinceUnixEpoch(uint!(1)));

examples/joke_bot/src/main.rs

@@ -9,7 +9,7 @@ use ruma::{
     assign, client,
     events::{
         room::message::{MessageType, RoomMessageEventContent},
-        AnySyncMessageLikeEvent, AnySyncRoomEvent, SyncMessageLikeEvent,
+        AnySyncMessageLikeEvent, AnySyncTimelineEvent, SyncMessageLikeEvent,
     },
     presence::PresenceState,
     serde::Raw,
@@ -145,11 +145,11 @@ async fn create_matrix_session(
 async fn handle_message(
     http_client: &HttpClient,
     matrix_client: &MatrixClient,
-    e: &Raw<AnySyncRoomEvent>,
+    e: &Raw<AnySyncTimelineEvent>,
     room_id: &RoomId,
     bot_user_id: &UserId,
 ) -> Result<(), Box<dyn Error>> {
-    if let Ok(AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
+    if let Ok(AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
         SyncMessageLikeEvent::Original(m),
     ))) = e.deserialize()
     {

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, OriginalSyncMessageLikeEvent,
+        AnySyncMessageLikeEvent, AnySyncTimelineEvent, OriginalSyncMessageLikeEvent,
         SyncMessageLikeEvent,
     },
     presence::PresenceState,
@@ -43,7 +43,7 @@ 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 AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
                     SyncMessageLikeEvent::Original(OriginalSyncMessageLikeEvent {
                         content:
                             RoomMessageEventContent {