Merge branch 'dev'

The result is FTBFS as yet; next commits will fix that, along with a few
other things.

36 files changed, 450 insertions, 527 deletions

diff --git a/lib/events/accountdataevents.h b/lib/events/accountdataevents.h
index e5101d20..12f1f00b 100644
--- a/lib/events/accountdataevents.h
+++ b/lib/events/accountdataevents.h
@@ -4,28 +4,24 @@
 #pragma once
 
 #include "event.h"
-#include "eventcontent.h"
+#include "util.h"
 
 namespace Quotient {
-constexpr const char* FavouriteTag = "m.favourite";
-constexpr const char* LowPriorityTag = "m.lowpriority";
-constexpr const char* ServerNoticeTag = "m.server_notice";
+constexpr auto FavouriteTag [[maybe_unused]] = "m.favourite"_ls;
+constexpr auto LowPriorityTag [[maybe_unused]] = "m.lowpriority"_ls;
+constexpr auto ServerNoticeTag [[maybe_unused]] = "m.server_notice"_ls;
 
 struct TagRecord {
-    using order_type = Omittable<float>;
-
-    order_type order;
-
-    TagRecord(order_type order = none) : order(std::move(order)) {}
-
-    bool operator<(const TagRecord& other) const
-    {
-        // Per The Spec, rooms with no order should be after those with order,
-        // against optional<>::operator<() convention.
-        return order && (!other.order || *order < *other.order);
-    }
+    Omittable<float> order = none;
 };
 
+inline bool operator<(TagRecord lhs, TagRecord rhs)
+{
+    // Per The Spec, rooms with no order should be after those with order,
+    // against std::optional<>::operator<() convention.
+    return lhs.order && (!rhs.order || *lhs.order < *rhs.order);
+}
+
 template <>
 struct JsonObjectConverter<TagRecord> {
     static void fillFrom(const QJsonObject& jo, TagRecord& rec)
@@ -42,7 +38,7 @@ struct JsonObjectConverter<TagRecord> {
                 rec.order = none;
         }
     }
-    static void dumpTo(QJsonObject& jo, const TagRecord& rec)
+    static void dumpTo(QJsonObject& jo, TagRecord rec)
     {
         addParam<IfNotEmpty>(jo, QStringLiteral("order"), rec.order);
     }
@@ -51,7 +47,7 @@ struct JsonObjectConverter<TagRecord> {
 using TagsMap = QHash<QString, TagRecord>;
 
 #define DEFINE_SIMPLE_EVENT(_Name, _TypeId, _ContentType, _ContentKey)       \
-    class _Name : public Event {                                             \
+    class QUOTIENT_API _Name : public Event {                             \
     public:                                                                  \
         using content_type = _ContentType;                                   \
         DEFINE_EVENT_TYPEID(_TypeId, _Name)                                  \
diff --git a/lib/events/callanswerevent.h b/lib/events/callanswerevent.h
index 4c01c941..8ffe60f2 100644
--- a/lib/events/callanswerevent.h
+++ b/lib/events/callanswerevent.h
@@ -7,7 +7,7 @@
 #include "roomevent.h"
 
 namespace Quotient {
-class CallAnswerEvent : public CallEventBase {
+class QUOTIENT_API CallAnswerEvent : public CallEventBase {
 public:
     DEFINE_EVENT_TYPEID("m.call.answer", CallAnswerEvent)
 
@@ -26,6 +26,5 @@ public:
         return contentPart<QJsonObject>("answer"_ls).value("sdp"_ls).toString();
     }
 };
-
 REGISTER_EVENT_TYPE(CallAnswerEvent)
 } // namespace Quotient
diff --git a/lib/events/callcandidatesevent.cpp b/lib/events/callcandidatesevent.cpp
deleted file mode 100644
index b87c8e9b..00000000
--- a/lib/events/callcandidatesevent.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: 2017 Marius Gripsgard <marius@ubports.com>
-// SPDX-FileCopyrightText: 2018 Josip Delic <delijati@googlemail.com>
-// SPDX-License-Identifier: LGPL-2.1-or-later
-
-#include "callcandidatesevent.h"
-
-/*
-m.call.candidates
-{
-    "age": 242352,
-    "content": {
-        "call_id": "12345",
-        "candidates": [
-            {
-                "candidate": "candidate:863018703 1 udp 2122260223 10.9.64.156
-43670 typ host generation 0", "sdpMLineIndex": 0, "sdpMid": "audio"
-            }
-        ],
-        "version": 0
-    },
-    "event_id": "$WLGTSEFSEF:localhost",
-    "origin_server_ts": 1431961217939,
-    "room_id": "!Cuyf34gef24t:localhost",
-    "sender": "@example:localhost",
-    "type": "m.call.candidates"
-}
-*/
diff --git a/lib/events/callhangupevent.cpp b/lib/events/callhangupevent.cpp
deleted file mode 100644
index 43bc4db0..00000000
--- a/lib/events/callhangupevent.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/******************************************************************************
- * SPDX-FileCopyrightText: 2017 Marius Gripsgard <marius@ubports.com>
- * SPDX-FileCopyrightText: 2018 Josip Delic <delijati@googlemail.com>
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#include "callhangupevent.h"
-
-/*
-m.call.hangup
-{
-    "age": 242352,
-    "content": {
-        "call_id": "12345",
-        "version": 0
-    },
-    "event_id": "$WLGTSEFSEF:localhost",
-    "origin_server_ts": 1431961217939,
-    "room_id": "!Cuyf34gef24t:localhost",
-    "sender": "@example:localhost",
-    "type": "m.call.hangup"
-}
-*/
-
-using namespace Quotient;
-
-CallHangupEvent::CallHangupEvent(const QJsonObject& obj)
-    : CallEventBase(typeId(), obj)
-{
-    qCDebug(EVENTS) << "Call Hangup event";
-}
-
-CallHangupEvent::CallHangupEvent(const QString& callId)
-    : CallEventBase(typeId(), matrixTypeId(), callId, 0)
-{}
diff --git a/lib/events/callhangupevent.h b/lib/events/callhangupevent.h
index 24382ac2..b0017c59 100644
--- a/lib/events/callhangupevent.h
+++ b/lib/events/callhangupevent.h
@@ -7,12 +7,16 @@
 #include "roomevent.h"
 
 namespace Quotient {
-class CallHangupEvent : public CallEventBase {
+class QUOTIENT_API CallHangupEvent : public CallEventBase {
 public:
     DEFINE_EVENT_TYPEID("m.call.hangup", CallHangupEvent)
 
-    explicit CallHangupEvent(const QJsonObject& obj);
-    explicit CallHangupEvent(const QString& callId);
+    explicit CallHangupEvent(const QJsonObject& obj)
+        : CallEventBase(typeId(), obj)
+    {}
+    explicit CallHangupEvent(const QString& callId)
+        : CallEventBase(typeId(), matrixTypeId(), callId, 0)
+    {}
 };
 
 REGISTER_EVENT_TYPE(CallHangupEvent)
diff --git a/lib/events/callinviteevent.h b/lib/events/callinviteevent.h
index 80b7d651..47362b5c 100644
--- a/lib/events/callinviteevent.h
+++ b/lib/events/callinviteevent.h
@@ -7,7 +7,7 @@
 #include "roomevent.h"
 
 namespace Quotient {
-class CallInviteEvent : public CallEventBase {
+class QUOTIENT_API CallInviteEvent : public CallEventBase {
 public:
     DEFINE_EVENT_TYPEID("m.call.invite", CallInviteEvent)
 
diff --git a/lib/events/directchatevent.h b/lib/events/directchatevent.h
index e2143779..2018d3d6 100644
--- a/lib/events/directchatevent.h
+++ b/lib/events/directchatevent.h
@@ -6,7 +6,7 @@
 #include "event.h"
 
 namespace Quotient {
-class DirectChatEvent : public Event {
+class QUOTIENT_API DirectChatEvent : public Event {
 public:
     DEFINE_EVENT_TYPEID("m.direct", DirectChatEvent)
 
diff --git a/lib/events/encryptedevent.h b/lib/events/encryptedevent.h
index 4cc3bf8e..c838bbd8 100644
--- a/lib/events/encryptedevent.h
+++ b/lib/events/encryptedevent.h
@@ -25,7 +25,7 @@ namespace Quotient {
  * in general. It's possible, because RoomEvent interface is similar to Event's
  * one and doesn't add new restrictions, just provides additional features.
  */
-class EncryptedEvent : public RoomEvent {
+class QUOTIENT_API EncryptedEvent : public RoomEvent {
 public:
     DEFINE_EVENT_TYPEID("m.room.encrypted", EncryptedEvent)
 
diff --git a/lib/events/encryptionevent.h b/lib/events/encryptionevent.h
index 14439fcc..124ced33 100644
--- a/lib/events/encryptionevent.h
+++ b/lib/events/encryptionevent.h
@@ -6,13 +6,18 @@
 
 #include "eventcontent.h"
 #include "stateevent.h"
+#include "quotient_common.h"
 
 namespace Quotient {
-class EncryptionEventContent : public EventContent::Base {
+class QUOTIENT_API EncryptionEventContent : public EventContent::Base {
 public:
     enum EncryptionType : size_t { MegolmV1AesSha2 = 0, Undefined };
 
-    explicit EncryptionEventContent(EncryptionType et = Undefined);
+    QUO_IMPLICIT EncryptionEventContent(EncryptionType et);
+    [[deprecated("This constructor will require explicit EncryptionType soon")]] //
+    explicit EncryptionEventContent()
+        : EncryptionEventContent(Undefined)
+    {}
     explicit EncryptionEventContent(const QJsonObject& json);
 
     EncryptionType encryption;
@@ -26,7 +31,7 @@ protected:
 
 using EncryptionType = EncryptionEventContent::EncryptionType;
 
-class EncryptionEvent : public StateEvent<EncryptionEventContent> {
+class QUOTIENT_API EncryptionEvent : public StateEvent<EncryptionEventContent> {
     Q_GADGET
 public:
     DEFINE_EVENT_TYPEID("m.room.encryption", EncryptionEvent)
@@ -34,15 +39,15 @@ public:
     using EncryptionType = EncryptionEventContent::EncryptionType;
     Q_ENUM(EncryptionType)
 
-    explicit EncryptionEvent(const QJsonObject& obj = {}) // TODO: apropriate
-                                                          // default value
+    explicit EncryptionEvent(const QJsonObject& obj)
         : StateEvent(typeId(), obj)
     {}
-    EncryptionEvent(EncryptionEvent&&) = delete;
-    template <typename... ArgTs>
-    EncryptionEvent(ArgTs&&... contentArgs)
-        : StateEvent(typeId(), matrixTypeId(), QString(),
-                     std::forward<ArgTs>(contentArgs)...)
+    [[deprecated("This constructor will require an explicit parameter soon")]] //
+//    explicit EncryptionEvent()
+//        : EncryptionEvent(QJsonObject())
+//    {}
+    explicit EncryptionEvent(EncryptionEventContent&& content)
+        : StateEvent(typeId(), matrixTypeId(), QString(), std::move(content))
     {}
 
     EncryptionType encryption() const { return content().encryption; }
@@ -51,6 +56,5 @@ public:
     int rotationPeriodMs() const { return content().rotationPeriodMs; }
     int rotationPeriodMsgs() const { return content().rotationPeriodMsgs; }
 };
-
 REGISTER_EVENT_TYPE(EncryptionEvent)
 } // namespace Quotient
diff --git a/lib/events/event.cpp b/lib/events/event.cpp
index 96be717c..4c304a3c 100644
--- a/lib/events/event.cpp
+++ b/lib/events/event.cpp
@@ -9,22 +9,14 @@
 
 using namespace Quotient;
 
-event_type_t EventTypeRegistry::initializeTypeId(event_mtype_t matrixTypeId)
-{
-    const auto id = get().eventTypes.size();
-    get().eventTypes.push_back(matrixTypeId);
-    if (strncmp(matrixTypeId, "", 1) == 0)
-        qDebug(EVENTS) << "Initialized unknown event type with id" << id;
-    else
-        qDebug(EVENTS) << "Initialized event type" << matrixTypeId << "with id"
-                       << id;
-    return id;
-}
+QString EventTypeRegistry::getMatrixType(event_type_t typeId) { return typeId; }
 
-QString EventTypeRegistry::getMatrixType(event_type_t typeId)
+void _impl::EventFactoryBase::logAddingMethod(event_type_t TypeId,
+                                              size_t newSize)
 {
-    return typeId < get().eventTypes.size() ? get().eventTypes[typeId]
-                                            : QString();
+    qDebug(EVENTS) << "Adding factory method for" << TypeId << "events;"
+                   << newSize << "methods will be in the" << name
+                   << "chain";
 }
 
 Event::Event(Type type, const QJsonObject& json) : _type(type), _json(json)
diff --git a/lib/events/event.h b/lib/events/event.h
index 998a386c..113fa3fa 100644
--- a/lib/events/event.h
+++ b/lib/events/event.h
@@ -5,6 +5,7 @@
 
 #include "converters.h"
 #include "logging.h"
+#include "function_traits.h"
 
 namespace Quotient {
 // === event_ptr_tt<> and type casting facilities ===
@@ -28,24 +29,24 @@ inline TargetEventT* weakPtrCast(const event_ptr_tt<EventT>& ptr)
 
 // === Standard Matrix key names and basicEventJson() ===
 
-static const auto TypeKey = QStringLiteral("type");
-static const auto BodyKey = QStringLiteral("body");
-static const auto ContentKey = QStringLiteral("content");
-static const auto EventIdKey = QStringLiteral("event_id");
-static const auto SenderKey = QStringLiteral("sender");
-static const auto RoomIdKey = QStringLiteral("room_id");
-static const auto UnsignedKey = QStringLiteral("unsigned");
-static const auto StateKeyKey = QStringLiteral("state_key");
-static const auto TypeKeyL = "type"_ls;
-static const auto BodyKeyL = "body"_ls;
-static const auto ContentKeyL = "content"_ls;
-static const auto EventIdKeyL = "event_id"_ls;
-static const auto SenderKeyL = "sender"_ls;
-static const auto RoomIdKeyL = "room_id"_ls;
-static const auto UnsignedKeyL = "unsigned"_ls;
-static const auto RedactedCauseKeyL = "redacted_because"_ls;
-static const auto PrevContentKeyL = "prev_content"_ls;
-static const auto StateKeyKeyL = "state_key"_ls;
+constexpr auto TypeKeyL = "type"_ls;
+constexpr auto BodyKeyL = "body"_ls;
+constexpr auto ContentKeyL = "content"_ls;
+constexpr auto EventIdKeyL = "event_id"_ls;
+constexpr auto SenderKeyL = "sender"_ls;
+constexpr auto RoomIdKeyL = "room_id"_ls;
+constexpr auto UnsignedKeyL = "unsigned"_ls;
+constexpr auto RedactedCauseKeyL = "redacted_because"_ls;
+constexpr auto PrevContentKeyL = "prev_content"_ls;
+constexpr auto StateKeyKeyL = "state_key"_ls;
+const QString TypeKey { TypeKeyL };
+const QString BodyKey { BodyKeyL };
+const QString ContentKey { ContentKeyL };
+const QString EventIdKey { EventIdKeyL };
+const QString SenderKey { SenderKeyL };
+const QString RoomIdKey { RoomIdKeyL };
+const QString UnsignedKey { UnsignedKeyL };
+const QString StateKeyKey { StateKeyKeyL };
 
 /// Make a minimal correct Matrix event JSON
 inline QJsonObject basicEventJson(const QString& matrixType,
@@ -54,149 +55,135 @@ inline QJsonObject basicEventJson(const QString& matrixType,
     return { { TypeKey, matrixType }, { ContentKey, content } };
 }
 
-// === Event types and event types registry ===
+// === Event types ===
 
-using event_type_t = size_t;
+using event_type_t = QLatin1String;
 using event_mtype_t = const char*;
 
-class EventTypeRegistry {
+class QUOTIENT_API EventTypeRegistry {
 public:
     ~EventTypeRegistry() = default;
 
-    static event_type_t initializeTypeId(event_mtype_t matrixTypeId);
-
-    template <typename EventT>
-    static inline event_type_t initializeTypeId()
-    {
-        return initializeTypeId(EventT::matrixTypeId());
-    }
-
+    [[deprecated("event_type_t is a string now, use it directly instead")]]
     static QString getMatrixType(event_type_t typeId);
 
 private:
     EventTypeRegistry() = default;
     Q_DISABLE_COPY_MOVE(EventTypeRegistry)
-
-    static EventTypeRegistry& get()
-    {
-        static EventTypeRegistry etr;
-        return etr;
-    }
-
-    std::vector<event_mtype_t> eventTypes;
-};
-
-template <>
-inline event_type_t EventTypeRegistry::initializeTypeId<void>()
-{
-    return initializeTypeId("");
-}
-
-template <typename EventT>
-struct EventTypeTraits {
-    static event_type_t id()
-    {
-        static const auto id = EventTypeRegistry::initializeTypeId<EventT>();
-        return id;
-    }
 };
 
 template <typename EventT>
-inline event_type_t typeId()
+constexpr event_type_t typeId()
 {
-    return EventTypeTraits<std::decay_t<EventT>>::id();
+    return std::decay_t<EventT>::TypeId;
 }
 
-inline event_type_t unknownEventTypeId() { return typeId<void>(); }
+constexpr event_type_t UnknownEventTypeId = "?"_ls;
+[[deprecated("Use UnknownEventTypeId")]]
+constexpr event_type_t unknownEventTypeId() { return UnknownEventTypeId; }
 
-// === EventFactory ===
+// === Event creation facilities ===
 
-/** Create an event of arbitrary type from its arguments */
+//! Create an event of arbitrary type from its arguments
 template <typename EventT, typename... ArgTs>
 inline event_ptr_tt<EventT> makeEvent(ArgTs&&... args)
 {
     return std::make_unique<EventT>(std::forward<ArgTs>(args)...);
 }
 
+namespace _impl {
+    class QUOTIENT_API EventFactoryBase {
+    public:
+        EventFactoryBase(const EventFactoryBase&) = delete;
+
+    protected: // This class is only to inherit from
+        explicit EventFactoryBase(const char* name)
+            : name(name)
+        {}
+        void logAddingMethod(event_type_t TypeId, size_t newSize);
+
+    private:
+        const char* const name;
+    };
+} // namespace _impl
+
+//! \brief A family of event factories to create events from CS API responses
+//!
+//! Each of these factories, as instantiated by event base types (Event,
+//! RoomEvent etc.) is capable of producing an event object derived from
+//! \p BaseEventT, using the JSON payload and the event type passed to its
+//! make() method. Don't use these directly to make events; use loadEvent()
+//! overloads as the frontend for these. Never instantiate new factories
+//! outside of base event classes.
+//! \sa loadEvent, setupFactory, Event::factory, RoomEvent::factory,
+//!     StateEventBase::factory
 template <typename BaseEventT>
-class EventFactory {
-public:
-    template <typename FnT>
-    static auto addMethod(FnT&& method)
+class EventFactory : public _impl::EventFactoryBase {
+private:
+    using method_t = event_ptr_tt<BaseEventT> (*)(const QJsonObject&,
+                                                  const QString&);
+    std::vector<method_t> methods {};
+
+    template <class EventT>
+    static event_ptr_tt<BaseEventT> makeIfMatches(const QJsonObject& json,
+                                                  const QString& matrixType)
     {
-        factories().emplace_back(std::forward<FnT>(method));
-        return 0;
+        // If your matrix event type is not all ASCII, it's your problem
+        // (see https://github.com/matrix-org/matrix-doc/pull/2758)
+        return EventT::TypeId == matrixType ? makeEvent<EventT>(json) : nullptr;
     }
 
-    /** Chain two type factories
-     * Adds the factory class of EventT2 (EventT2::factory_t) to
-     * the list in factory class of EventT1 (EventT1::factory_t) so
-     * that when EventT1::factory_t::make() is invoked, types of
-     * EventT2 factory are looked through as well. This is used
-     * to include RoomEvent types into the more general Event factory,
-     * and state event types into the RoomEvent factory.
-     */
-    template <typename EventT>
-    static auto chainFactory()
+public:
+    explicit EventFactory(const char* fName)
+        : EventFactoryBase { fName }
+    {}
+
+    //! \brief Add a method to create events of a given type
+    //!
+    //! Adds a standard factory method (makeIfMatches) for \p EventT so that
+    //! event objects of this type can be created dynamically by loadEvent.
+    //! The caller is responsible for ensuring this method is called only
+    //! once per type.
+    //! \sa loadEvent, Quotient::loadEvent
+    template <class EventT>
+    const auto& addMethod()
     {
-        return addMethod(&EventT::factory_t::make);
+        const auto m = &makeIfMatches<EventT>;
+        const auto it = std::find(methods.cbegin(), methods.cend(), m);
+        if (it != methods.cend())
+            return *it;
+        logAddingMethod(EventT::TypeId, methods.size() + 1);
+        return methods.emplace_back(m);
     }
 
-    static event_ptr_tt<BaseEventT> make(const QJsonObject& json,
-                                         const QString& matrixType)
+    auto loadEvent(const QJsonObject& json, const QString& matrixType)
     {
-        for (const auto& f : factories())
+        for (const auto& f : methods)
             if (auto e = f(json, matrixType))
                 return e;
-        return nullptr;
-    }
-
-private:
-    static auto& factories()
-    {
-        using inner_factory_tt = std::function<event_ptr_tt<BaseEventT>(
-            const QJsonObject&, const QString&)>;
-        static std::vector<inner_factory_tt> _factories {};
-        return _factories;
+        return makeEvent<BaseEventT>(UnknownEventTypeId, json);
     }
 };
 
-/** Add a type to its default factory
- * Adds a standard factory method (via makeEvent<>) for a given
- * type to EventT::factory_t factory class so that it can be
- * created dynamically from loadEvent<>().
- *
- * \tparam EventT the type to enable dynamic creation of
- * \return the registered type id
- * \sa loadEvent, Event::type
- */
-template <typename EventT>
-inline auto setupFactory()
-{
-    qDebug(EVENTS) << "Adding factory method for" << EventT::matrixTypeId();
-    return EventT::factory_t::addMethod([](const QJsonObject& json,
-                                           const QString& jsonMatrixType) {
-        return EventT::matrixTypeId() == jsonMatrixType ? makeEvent<EventT>(json)
-                                                        : nullptr;
-    });
-}
-
-template <typename EventT>
-inline auto registerEventType()
+//! \brief Point of customisation to dynamically load events
+//!
+//! The default specialisation of this calls BaseEventT::factory.loadEvent()
+//! and if that fails (i.e. returns nullptr) creates an unknown event of
+//! BaseEventT. Other specialisations may reuse other factories, add validations
+//! common to BaseEventT events, and so on.
+template <class BaseEventT>
+event_ptr_tt<BaseEventT> doLoadEvent(const QJsonObject& json,
+                                     const QString& matrixType)
 {
-    // Initialise exactly once, even if this function is called twice for
-    // the same type (for whatever reason - you never know the ways of
-    // static initialisation is done).
-    static const auto _ = setupFactory<EventT>();
-    return _; // Only to facilitate usage in static initialisation
+    return BaseEventT::factory.loadEvent(json, matrixType);
 }
 
 // === Event ===
 
-class Event {
+class QUOTIENT_API Event {
 public:
     using Type = event_type_t;
-    using factory_t = EventFactory<Event>;
+    static inline EventFactory<Event> factory { "Event" };
 
     explicit Event(Type type, const QJsonObject& json);
     explicit Event(Type type, event_mtype_t matrixType,
@@ -246,7 +233,7 @@ public:
         return fromJson<T>(unsignedJson()[std::forward<KeyT>(key)]);
     }
 
-    friend QDebug operator<<(QDebug dbg, const Event& e)
+    friend QUOTIENT_API QDebug operator<<(QDebug dbg, const Event& e)
     {
         QDebugStateSaver _dss { dbg };
         dbg.noquote().nospace() << e.matrixType() << '(' << e.type() << "): ";
@@ -271,26 +258,27 @@ template <typename EventT>
 using EventsArray = std::vector<event_ptr_tt<EventT>>;
 using Events = EventsArray<Event>;
 
-// === Macros used with event class definitions ===
+// === Facilities for event class definitions ===
 
 // This macro should be used in a public section of an event class to
 // provide matrixTypeId() and typeId().
-#define DEFINE_EVENT_TYPEID(_Id, _Type)                           \
-    static constexpr event_mtype_t matrixTypeId() { return _Id; } \
-    static auto typeId() { return Quotient::typeId<_Type>(); }    \
+#define DEFINE_EVENT_TYPEID(Id_, Type_)                           \
+    static constexpr event_type_t TypeId = Id_##_ls;              \
+    [[deprecated("Use " #Type_ "::TypeId directly instead")]]     \
+    static constexpr event_mtype_t matrixTypeId() { return Id_; } \
+    [[deprecated("Use " #Type_ "::TypeId directly instead")]]     \
+    static event_type_t typeId() { return TypeId; }               \
     // End of macro
 
 // This macro should be put after an event class definition (in .h or .cpp)
 // to enable its deserialisation from a /sync and other
 // polymorphic event arrays
-#define REGISTER_EVENT_TYPE(_Type)                                \
-    namespace {                                                   \
-        [[maybe_unused]] static const auto _factoryAdded##_Type = \
-            registerEventType<_Type>();                           \
-    }                                                             \
+#define REGISTER_EVENT_TYPE(Type_)                                \
+    [[maybe_unused]] inline const auto& factoryMethodFor##Type_ = \
+        Type_::factory.addMethod<Type_>();                        \
     // End of macro
 
-// === is<>(), eventCast<>() and visit<>() ===
+// === is<>(), eventCast<>() and switchOnType<>() ===
 
 template <class EventT>
 inline bool is(const Event& e)
@@ -300,7 +288,7 @@ inline bool is(const Event& e)
 
 inline bool isUnknown(const Event& e)
 {
-    return e.type() == unknownEventTypeId();
+    return e.type() == UnknownEventTypeId;
 }
 
 template <class EventT, typename BasePtrT>
@@ -312,68 +300,75 @@ inline auto eventCast(const BasePtrT& eptr)
                                            : nullptr;
 }
 
-// A single generic catch-all visitor
+// A trivial generic catch-all "switch"
 template <class BaseEventT, typename FnT>
-inline auto visit(const BaseEventT& event, FnT&& visitor)
-    -> decltype(visitor(event))
+inline auto switchOnType(const BaseEventT& event, FnT&& fn)
+    -> decltype(fn(event))
 {
-    return visitor(event);
+    return fn(event);
 }
 
 namespace _impl {
     // Using bool instead of auto below because auto apparently upsets MSVC
     template <class BaseT, typename FnT>
-    inline constexpr bool needs_downcast =
+    constexpr bool needs_downcast =
         std::is_base_of_v<BaseT, std::decay_t<fn_arg_t<FnT>>>
         && !std::is_same_v<BaseT, std::decay_t<fn_arg_t<FnT>>>;
 }
 
-// A single type-specific void visitor
+// A trivial type-specific "switch" for a void function
 template <class BaseT, typename FnT>
-inline auto visit(const BaseT& event, FnT&& visitor)
+inline auto switchOnType(const BaseT& event, FnT&& fn)
     -> std::enable_if_t<_impl::needs_downcast<BaseT, FnT>
                         && std::is_void_v<fn_return_t<FnT>>>
 {
     using event_type = fn_arg_t<FnT>;
     if (is<std::decay_t<event_type>>(event))
-        visitor(static_cast<event_type>(event));
+        fn(static_cast<event_type>(event));
 }
 
-// A single type-specific non-void visitor with an optional default value
-// non-voidness is guarded by defaultValue type
+// A trivial type-specific "switch" for non-void functions with an optional
+// default value; non-voidness is guarded by defaultValue type
 template <class BaseT, typename FnT>
-inline auto visit(const BaseT& event, FnT&& visitor,
-                  fn_return_t<FnT>&& defaultValue = {})
+inline auto switchOnType(const BaseT& event, FnT&& fn,
+                         fn_return_t<FnT>&& defaultValue = {})
     -> std::enable_if_t<_impl::needs_downcast<BaseT, FnT>, fn_return_t<FnT>>
 {
     using event_type = fn_arg_t<FnT>;
     if (is<std::decay_t<event_type>>(event))
-        return visitor(static_cast<event_type>(event));
-    return std::forward<fn_return_t<FnT>>(defaultValue);
+        return fn(static_cast<event_type>(event));
+    return std::move(defaultValue);
 }
 
-// A chain of 2 or more visitors
+// A switch for a chain of 2 or more functions
 template <class BaseT, typename FnT1, typename FnT2, typename... FnTs>
-inline std::common_type_t<fn_return_t<FnT1>, fn_return_t<FnT2>> visit(
-        const BaseT& event, FnT1&& visitor1, FnT2&& visitor2,
-        FnTs&&... visitors)
+inline std::common_type_t<fn_return_t<FnT1>, fn_return_t<FnT2>>
+switchOnType(const BaseT& event, FnT1&& fn1, FnT2&& fn2, FnTs&&... fns)
 {
     using event_type1 = fn_arg_t<FnT1>;
     if (is<std::decay_t<event_type1>>(event))
-        return visitor1(static_cast<event_type1&>(event));
-    return visit(event, std::forward<FnT2>(visitor2),
-                 std::forward<FnTs>(visitors)...);
+        return fn1(static_cast<event_type1&>(event));
+    return switchOnType(event, std::forward<FnT2>(fn2),
+                        std::forward<FnTs>(fns)...);
+}
+
+template <class BaseT, typename... FnTs>
+[[deprecated("The new name for visit() is switchOnType()")]] //
+inline auto visit(const BaseT& event, FnTs&&... fns)
+{
+    return switchOnType(event, std::forward<FnTs>(fns)...);
 }
 
-// A facility overload that calls void-returning visit() on each event
+    // A facility overload that calls void-returning switchOnType() on each event
 // over a range of event pointers
+// TODO: replace with ranges::for_each once all standard libraries have it
 template <typename RangeT, typename... FnTs>
-inline auto visitEach(RangeT&& events, FnTs&&... visitors)
+inline auto visitEach(RangeT&& events, FnTs&&... fns)
     -> std::enable_if_t<std::is_void_v<
-            decltype(visit(**begin(events), std::forward<FnTs>(visitors)...))>>
+        decltype(switchOnType(**begin(events), std::forward<FnTs>(fns)...))>>
 {
     for (auto&& evtPtr: events)
-        visit(*evtPtr, std::forward<FnTs>(visitors)...);
+        switchOnType(*evtPtr, std::forward<FnTs>(fns)...);
 }
 } // namespace Quotient
 Q_DECLARE_METATYPE(Quotient::Event*)
diff --git a/lib/events/eventcontent.cpp b/lib/events/eventcontent.cpp
index d4cb43ff..9d7edf20 100644
--- a/lib/events/eventcontent.cpp
+++ b/lib/events/eventcontent.cpp
@@ -4,7 +4,6 @@
 #include "eventcontent.h"
 
 #include "converters.h"
-#include "util.h"
 #include "logging.h"
 
 #include <QtCore/QMimeDatabase>
diff --git a/lib/events/eventcontent.h b/lib/events/eventcontent.h
index f609a603..de9a792b 100644
--- a/lib/events/eventcontent.h
+++ b/lib/events/eventcontent.h
@@ -6,14 +6,15 @@
 // This file contains generic event content definitions, applicable to room
 // message events as well as other events (e.g., avatars).
 
+#include "encryptedfile.h"
+#include "quotient_export.h"
+
 #include <QtCore/QJsonObject>
 #include <QtCore/QMimeType>
 #include <QtCore/QSize>
 #include <QtCore/QUrl>
 #include <QtCore/QMetaType>
 
-#include "encryptedfile.h"
-
 class QFileInfo;
 
 namespace Quotient {
@@ -28,7 +29,7 @@ namespace EventContent {
      * assumed but not required that a content object can also be created
      * from plain data.
      */
-    class Base {
+    class QUOTIENT_API Base {
     public:
         explicit Base(QJsonObject o = {}) : originalJson(std::move(o)) {}
         virtual ~Base() = default;
@@ -76,7 +77,7 @@ namespace EventContent {
      *
      * This class is not polymorphic.
      */
-    class FileInfo {
+    class QUOTIENT_API FileInfo {
     public:
         FileInfo() = default;
         explicit FileInfo(const QFileInfo& fi);
@@ -105,7 +106,7 @@ namespace EventContent {
         QJsonObject originalInfoJson;
         QMimeType mimeType;
         QUrl url;
-        qint64 payloadSize;
+        qint64 payloadSize = 0;
         QString originalName;
         Omittable<EncryptedFile> file = none;
     };
@@ -121,7 +122,7 @@ namespace EventContent {
     /**
      * A content info class for image content types: image, thumbnail, video
      */
-    class ImageInfo : public FileInfo {
+    class QUOTIENT_API ImageInfo : public FileInfo {
     public:
         ImageInfo() = default;
         explicit ImageInfo(const QFileInfo& fi, QSize imageSize = {});
@@ -146,12 +147,10 @@ namespace EventContent {
      * the JSON representation of event content; namely,
      * "info/thumbnail_url" and "info/thumbnail_info" fields are used.
      */
-    class Thumbnail : public ImageInfo {
+    class QUOTIENT_API Thumbnail : public ImageInfo {
     public:
-        Thumbnail() = default; // Allow empty thumbnails
-        Thumbnail(const QJsonObject& infoJson, const Omittable<EncryptedFile> &file = none);
-        Thumbnail(const ImageInfo& info) : ImageInfo(info) {}
         using ImageInfo::ImageInfo;
+        Thumbnail(const QJsonObject& infoJson, const Omittable<EncryptedFile> &file = none);
 
         /**
          * Writes thumbnail information to "thumbnail_info" subobject
@@ -160,7 +159,7 @@ namespace EventContent {
         void fillInfoJson(QJsonObject* infoJson) const;
     };
 
-    class TypedBase : public Base {
+    class QUOTIENT_API TypedBase : public Base {
     public:
         virtual QMimeType type() const = 0;
         virtual const FileInfo* fileInfo() const { return nullptr; }
@@ -183,7 +182,7 @@ namespace EventContent {
      * \tparam InfoT base info class
      */
     template <class InfoT>
-    class UrlBasedContent : public TypedBase, public InfoT {
+    class QUOTIENT_API UrlBasedContent : public TypedBase, public InfoT {
     public:
         using InfoT::InfoT;
         explicit UrlBasedContent(const QJsonObject& json)
@@ -215,7 +214,7 @@ namespace EventContent {
     };
 
     template <typename InfoT>
-    class UrlWithThumbnailContent : public UrlBasedContent<InfoT> {
+    class QUOTIENT_API UrlWithThumbnailContent : public UrlBasedContent<InfoT> {
     public:
         // NB: when using inherited constructors, thumbnail has to be
         // initialised separately
diff --git a/lib/events/eventloader.h b/lib/events/eventloader.h
index 978668f2..fe624d70 100644
--- a/lib/events/eventloader.h
+++ b/lib/events/eventloader.h
@@ -6,16 +6,6 @@
 #include "stateevent.h"
 
 namespace Quotient {
-namespace _impl {
-    template <typename BaseEventT>
-    static inline auto loadEvent(const QJsonObject& json,
-                                 const QString& matrixType)
-    {
-        if (auto e = EventFactory<BaseEventT>::make(json, matrixType))
-            return e;
-        return makeEvent<BaseEventT>(unknownEventTypeId(), json);
-    }
-} // namespace _impl
 
 /*! Create an event with proper type from a JSON object
  *
@@ -26,7 +16,7 @@ namespace _impl {
 template <typename BaseEventT>
 inline event_ptr_tt<BaseEventT> loadEvent(const QJsonObject& fullJson)
 {
-    return _impl::loadEvent<BaseEventT>(fullJson, fullJson[TypeKeyL].toString());
+    return doLoadEvent<BaseEventT>(fullJson, fullJson[TypeKeyL].toString());
 }
 
 /*! Create an event from a type string and content JSON
@@ -39,8 +29,8 @@ template <typename BaseEventT>
 inline event_ptr_tt<BaseEventT> loadEvent(const QString& matrixType,
                                           const QJsonObject& content)
 {
-    return _impl::loadEvent<BaseEventT>(basicEventJson(matrixType, content),
-                                        matrixType);
+    return doLoadEvent<BaseEventT>(basicEventJson(matrixType, content),
+                                   matrixType);
 }
 
 /*! Create a state event from a type string, content JSON and state key
@@ -53,7 +43,7 @@ inline StateEventPtr loadStateEvent(const QString& matrixType,
                                     const QJsonObject& content,
                                     const QString& stateKey = {})
 {
-    return _impl::loadEvent<StateEventBase>(
+    return doLoadEvent<StateEventBase>(
         basicStateEventJson(matrixType, content, stateKey), matrixType);
 }
 
diff --git a/lib/events/eventrelation.cpp b/lib/events/eventrelation.cpp
new file mode 100644
index 00000000..04972f45
--- /dev/null
+++ b/lib/events/eventrelation.cpp
@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: 2022 Kitsune Ral <kitsune-ral@users.sf.net>
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#include "eventrelation.h"
+
+#include "../logging.h"
+#include "event.h"
+
+using namespace Quotient;
+
+void JsonObjectConverter<EventRelation>::dumpTo(QJsonObject& jo,
+                                                const EventRelation& pod)
+{
+    if (pod.type.isEmpty()) {
+        qCWarning(MAIN) << "Empty relation type; won't dump to JSON";
+        return;
+    }
+    jo.insert(RelTypeKey, pod.type);
+    jo.insert(EventIdKey, pod.eventId);
+    if (pod.type == EventRelation::AnnotationType)
+        jo.insert(QStringLiteral("key"), pod.key);
+}
+
+void JsonObjectConverter<EventRelation>::fillFrom(const QJsonObject& jo,
+                                                  EventRelation& pod)
+{
+    if (const auto replyJson = jo.value(EventRelation::ReplyType).toObject();
+        !replyJson.isEmpty()) {
+        pod.type = EventRelation::ReplyType;
+        fromJson(replyJson[EventIdKeyL], pod.eventId);
+    } else {
+        // The experimental logic for generic relationships (MSC1849)
+        fromJson(jo[RelTypeKey], pod.type);
+        fromJson(jo[EventIdKeyL], pod.eventId);
+        if (pod.type == EventRelation::AnnotationType)
+            fromJson(jo["key"_ls], pod.key);
+    }
+}
diff --git a/lib/events/eventrelation.h b/lib/events/eventrelation.h
new file mode 100644
index 00000000..e445ee42
--- /dev/null
+++ b/lib/events/eventrelation.h
@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: 2022 Kitsune Ral <kitsune-ral@users.sf.net>
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#pragma once
+
+#include "converters.h"
+
+namespace Quotient {
+
+[[maybe_unused]] constexpr auto RelatesToKey = "m.relates_to"_ls;
+constexpr auto RelTypeKey = "rel_type"_ls;
+
+struct QUOTIENT_API EventRelation {
+    using reltypeid_t = QLatin1String;
+
+    QString type;
+    QString eventId;
+    QString key = {}; // Only used for m.annotation for now
+
+    static constexpr auto ReplyType = "m.in_reply_to"_ls;
+    static constexpr auto AnnotationType = "m.annotation"_ls;
+    static constexpr auto ReplacementType = "m.replace"_ls;
+
+    static EventRelation replyTo(QString eventId)
+    {
+        return { ReplyType, std::move(eventId) };
+    }
+    static EventRelation annotate(QString eventId, QString key)
+    {
+        return { AnnotationType, std::move(eventId), std::move(key) };
+    }
+    static EventRelation replace(QString eventId)
+    {
+        return { ReplacementType, std::move(eventId) };
+    }
+
+    [[deprecated("Use ReplyRelation variable instead")]]
+    static constexpr auto Reply() { return ReplyType; }
+    [[deprecated("Use AnnotationRelation variable instead")]] //
+    static constexpr auto Annotation() { return AnnotationType; }
+    [[deprecated("Use ReplacementRelation variable instead")]] //
+    static constexpr auto Replacement() { return ReplacementType; }
+};
+
+template <>
+struct QUOTIENT_API JsonObjectConverter<EventRelation> {
+    static void dumpTo(QJsonObject& jo, const EventRelation& pod);
+    static void fillFrom(const QJsonObject& jo, EventRelation& pod);
+};
+
+}
+
diff --git a/lib/events/reactionevent.cpp b/lib/events/reactionevent.cpp
deleted file mode 100644
index b53fffd6..00000000
--- a/lib/events/reactionevent.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// SPDX-FileCopyrightText: 2019 Kitsune Ral <kitsune-ral@users.sf.net>
-// SPDX-License-Identifier: LGPL-2.1-or-later
-
-#include "reactionevent.h"
-
-using namespace Quotient;
-
-void JsonObjectConverter<EventRelation>::dumpTo(
-    QJsonObject& jo, const EventRelation& pod)
-{
-    if (pod.type.isEmpty()) {
-        qCWarning(MAIN) << "Empty relation type; won't dump to JSON";
-        return;
-    }
-    jo.insert(QStringLiteral("rel_type"), pod.type);
-    jo.insert(EventIdKey, pod.eventId);
-    if (pod.type == EventRelation::Annotation())
-        jo.insert(QStringLiteral("key"), pod.key);
-}
-
-void JsonObjectConverter<EventRelation>::fillFrom(
-    const QJsonObject& jo, EventRelation& pod)
-{
-    // The experimental logic for generic relationships (MSC1849)
-    fromJson(jo["rel_type"_ls], pod.type);
-    fromJson(jo[EventIdKeyL], pod.eventId);
-    if (pod.type == EventRelation::Annotation())
-        fromJson(jo["key"_ls], pod.key);
-}
diff --git a/lib/events/reactionevent.h b/lib/events/reactionevent.h
index 5a2b98c4..b3cb3ca7 100644
--- a/lib/events/reactionevent.h
+++ b/lib/events/reactionevent.h
@@ -4,39 +4,11 @@
 #pragma once
 
 #include "roomevent.h"
+#include "eventrelation.h"
 
 namespace Quotient {
 
-struct EventRelation {
-    using reltypeid_t = const char*;
-    static constexpr reltypeid_t Reply() { return "m.in_reply_to"; }
-    static constexpr reltypeid_t Annotation() { return "m.annotation"; }
-    static constexpr reltypeid_t Replacement() { return "m.replace"; }
-
-    QString type;
-    QString eventId;
-    QString key = {}; // Only used for m.annotation for now
-
-    static EventRelation replyTo(QString eventId)
-    {
-        return { Reply(), std::move(eventId) };
-    }
-    static EventRelation annotate(QString eventId, QString key)
-    {
-        return { Annotation(), std::move(eventId), std::move(key) };
-    }
-    static EventRelation replace(QString eventId)
-    {
-        return { Replacement(), std::move(eventId) };
-    }
-};
-template <>
-struct JsonObjectConverter<EventRelation> {
-    static void dumpTo(QJsonObject& jo, const EventRelation& pod);
-    static void fillFrom(const QJsonObject& jo, EventRelation& pod);
-};
-
-class ReactionEvent : public RoomEvent {
+class QUOTIENT_API ReactionEvent : public RoomEvent {
 public:
     DEFINE_EVENT_TYPEID("m.reaction", ReactionEvent)
 
@@ -47,7 +19,7 @@ public:
     explicit ReactionEvent(const QJsonObject& obj) : RoomEvent(typeId(), obj) {}
     EventRelation relation() const
     {
-        return contentPart<EventRelation>("m.relates_to"_ls);
+        return contentPart<EventRelation>(RelatesToKey);
     }
 };
 REGISTER_EVENT_TYPE(ReactionEvent)
diff --git a/lib/events/receiptevent.cpp b/lib/events/receiptevent.cpp
index 72dbf2e3..7f06d99f 100644
--- a/lib/events/receiptevent.cpp
+++ b/lib/events/receiptevent.cpp
@@ -20,7 +20,6 @@ Example of a Receipt Event:
 
 #include "receiptevent.h"
 
-#include "converters.h"
 #include "logging.h"
 
 using namespace Quotient;
diff --git a/lib/events/receiptevent.h b/lib/events/receiptevent.h
index 9683deef..5e077e47 100644
--- a/lib/events/receiptevent.h
+++ b/lib/events/receiptevent.h
@@ -19,7 +19,7 @@ struct ReceiptsForEvent {
 };
 using EventsWithReceipts = QVector<ReceiptsForEvent>;
 
-class ReceiptEvent : public Event {
+class QUOTIENT_API ReceiptEvent : public Event {
 public:
     DEFINE_EVENT_TYPEID("m.receipt", ReceiptEvent)
     explicit ReceiptEvent(const EventsWithReceipts& ewrs);
diff --git a/lib/events/roomavatarevent.h b/lib/events/roomavatarevent.h
index 8618ba31..c54b5801 100644
--- a/lib/events/roomavatarevent.h
+++ b/lib/events/roomavatarevent.h
@@ -7,7 +7,8 @@
 #include "stateevent.h"
 
 namespace Quotient {
-class RoomAvatarEvent : public StateEvent<EventContent::ImageContent> {
+class QUOTIENT_API RoomAvatarEvent
+    : public StateEvent<EventContent::ImageContent> {
     // It's a bit of an overkill to use a full-fledged ImageContent
     // because in reality m.room.avatar usually only has a single URL,
     // without a thumbnail. But The Spec says there be thumbnails, and
diff --git a/lib/events/roomcreateevent.h b/lib/events/roomcreateevent.h
index b3ad287c..989030ac 100644
--- a/lib/events/roomcreateevent.h
+++ b/lib/events/roomcreateevent.h
@@ -7,11 +7,10 @@
 #include "quotient_common.h"
 
 namespace Quotient {
-class RoomCreateEvent : public StateEventBase {
+class QUOTIENT_API RoomCreateEvent : public StateEventBase {
 public:
     DEFINE_EVENT_TYPEID("m.room.create", RoomCreateEvent)
 
-    explicit RoomCreateEvent() : StateEventBase(typeId(), matrixTypeId()) {}
     explicit RoomCreateEvent(const QJsonObject& obj)
         : StateEventBase(typeId(), obj)
     {}
diff --git a/lib/events/roomevent.cpp b/lib/events/roomevent.cpp
index eb5d0485..2f482871 100644
--- a/lib/events/roomevent.cpp
+++ b/lib/events/roomevent.cpp
@@ -3,15 +3,11 @@
 
 #include "roomevent.h"
 
-#include "converters.h"
 #include "logging.h"
 #include "redactionevent.h"
 
 using namespace Quotient;
 
-[[maybe_unused]] static auto roomEventTypeInitialised =
-    Event::factory_t::chainFactory<RoomEvent>();
-
 RoomEvent::RoomEvent(Type type, event_mtype_t matrixType,
                      const QJsonObject& contentJson)
     : Event(type, matrixType, contentJson)
diff --git a/lib/events/roomevent.h b/lib/events/roomevent.h
index 3d46bf9b..c4b0131a 100644
--- a/lib/events/roomevent.h
+++ b/lib/events/roomevent.h
@@ -11,9 +11,9 @@ namespace Quotient {
 class RedactionEvent;
 
 /** This class corresponds to m.room.* events */
-class RoomEvent : public Event {
+class QUOTIENT_API RoomEvent : public Event {
 public:
-    using factory_t = EventFactory<RoomEvent>;
+    static inline EventFactory<RoomEvent> factory { "RoomEvent" };
 
     // RedactionEvent is an incomplete type here so we cannot inline
     // constructors and destructors and we cannot use 'using'.
@@ -80,7 +80,7 @@ using RoomEventPtr = event_ptr_tt<RoomEvent>;
 using RoomEvents = EventsArray<RoomEvent>;
 using RoomEventsRange = Range<RoomEvents>;
 
-class CallEventBase : public RoomEvent {
+class QUOTIENT_API CallEventBase : public RoomEvent {
 public:
     CallEventBase(Type type, event_mtype_t matrixType, const QString& callId,
                   int version, const QJsonObject& contentJson = {});
diff --git a/lib/events/roomkeyevent.h b/lib/events/roomkeyevent.h
index d021fbec..c4df7936 100644
--- a/lib/events/roomkeyevent.h
+++ b/lib/events/roomkeyevent.h
@@ -6,7 +6,7 @@
 #include "event.h"
 
 namespace Quotient {
-class RoomKeyEvent : public Event
+class QUOTIENT_API RoomKeyEvent : public Event
 {
 public:
     DEFINE_EVENT_TYPEID("m.room_key", RoomKeyEvent)
diff --git a/lib/events/roommemberevent.cpp b/lib/events/roommemberevent.cpp
index b0bc7bcb..b4770224 100644
--- a/lib/events/roommemberevent.cpp
+++ b/lib/events/roommemberevent.cpp
@@ -4,7 +4,6 @@
 
 #include "roommemberevent.h"
 
-#include "converters.h"
 #include "logging.h"
 
 #include <QtCore/QtAlgorithms>
@@ -48,11 +47,9 @@ void MemberEventContent::fillJson(QJsonObject* o) const
 {
     Q_ASSERT(o);
     if (membership != Membership::Invalid)
-        o->insert(
-            QStringLiteral("membership"),
-            MembershipStrings[qCountTrailingZeroBits(
-                                  std::underlying_type_t<Membership>(membership))
-                              + 1]);
+        o->insert(QStringLiteral("membership"),
+                  MembershipStrings[qCountTrailingZeroBits(
+                      std::underlying_type_t<Membership>(membership))]);
     if (displayName)
         o->insert(QStringLiteral("displayname"), *displayName);
     if (avatarUrl && avatarUrl->isValid())
diff --git a/lib/events/roommemberevent.h b/lib/events/roommemberevent.h
index f3047159..ceb7826b 100644
--- a/lib/events/roommemberevent.h
+++ b/lib/events/roommemberevent.h
@@ -10,14 +10,12 @@
 #include "quotient_common.h"
 
 namespace Quotient {
-class MemberEventContent : public EventContent::Base {
+class QUOTIENT_API MemberEventContent : public EventContent::Base {
 public:
     using MembershipType
         [[deprecated("Use Quotient::Membership instead")]] = Membership;
 
-    explicit MemberEventContent(Membership ms = Membership::Join)
-        : membership(ms)
-    {}
+    QUO_IMPLICIT MemberEventContent(Membership ms) : membership(ms) {}
     explicit MemberEventContent(const QJsonObject& json);
 
     Membership membership;
@@ -33,7 +31,7 @@ protected:
 
 using MembershipType [[deprecated("Use Membership instead")]] = Membership;
 
-class RoomMemberEvent : public StateEvent<MemberEventContent> {
+class QUOTIENT_API RoomMemberEvent : public StateEvent<MemberEventContent> {
     Q_GADGET
 public:
     DEFINE_EVENT_TYPEID("m.room.member", RoomMemberEvent)
@@ -43,22 +41,19 @@ public:
 
     explicit RoomMemberEvent(const QJsonObject& obj) : StateEvent(typeId(), obj)
     {}
-    template <typename... ArgTs>
-    RoomMemberEvent(const QString& userId, ArgTs&&... contentArgs)
-        : StateEvent(typeId(), matrixTypeId(), userId,
-                     std::forward<ArgTs>(contentArgs)...)
+    RoomMemberEvent(const QString& userId, MemberEventContent&& content)
+        : StateEvent(typeId(), matrixTypeId(), userId, std::move(content))
     {}
 
-    /// A special constructor to create unknown RoomMemberEvents
-    /**
-     * This is needed in order to use RoomMemberEvent as a "base event
-     * class" in cases like GetMembersByRoomJob when RoomMemberEvents
-     * (rather than RoomEvents or StateEvents) are resolved from JSON.
-     * For such cases loadEvent<> requires an underlying class to be
-     * constructible with unknownTypeId() instead of its genuine id.
-     * Don't use it directly.
-     * \sa GetMembersByRoomJob, loadEvent, unknownTypeId
-     */
+    //! \brief A special constructor to create unknown RoomMemberEvents
+    //!
+    //! This is needed in order to use RoomMemberEvent as a "base event class"
+    //! in cases like GetMembersByRoomJob when RoomMemberEvents (rather than
+    //! RoomEvents or StateEvents) are resolved from JSON. For such cases
+    //! loadEvent\<> requires an underlying class to have a specialisation of
+    //! EventFactory\<> and be constructible with unknownTypeId() instead of
+    //! its genuine id. Don't use directly.
+    //! \sa EventFactory, loadEvent, GetMembersByRoomJob
     RoomMemberEvent(Type type, const QJsonObject& fullJson)
         : StateEvent(type, fullJson)
     {}
@@ -89,14 +84,12 @@ public:
 };
 
 template <>
-class EventFactory<RoomMemberEvent> {
-public:
-    static event_ptr_tt<RoomMemberEvent> make(const QJsonObject& json,
-                                              const QString&)
-    {
+inline event_ptr_tt<RoomMemberEvent>
+doLoadEvent<RoomMemberEvent>(const QJsonObject& json, const QString& matrixType)
+{
+    if (matrixType == QLatin1String(RoomMemberEvent::matrixTypeId()))
         return makeEvent<RoomMemberEvent>(json);
-    }
-};
-
+    return makeEvent<RoomMemberEvent>(unknownEventTypeId(), json);
+}
 REGISTER_EVENT_TYPE(RoomMemberEvent)
 } // namespace Quotient
diff --git a/lib/events/roommessageevent.cpp b/lib/events/roommessageevent.cpp
index 2b7b4166..d63352cb 100644
--- a/lib/events/roommessageevent.cpp
+++ b/lib/events/roommessageevent.cpp
@@ -6,6 +6,7 @@
 #include "roommessageevent.h"
 
 #include "logging.h"
+#include "events/eventrelation.h"
 
 #include <QtCore/QFileInfo>
 #include <QtCore/QMimeDatabase>
@@ -19,15 +20,14 @@ using namespace EventContent;
 
 using MsgType = RoomMessageEvent::MsgType;
 
-static const auto RelatesToKeyL = "m.relates_to"_ls;
-static const auto MsgTypeKeyL = "msgtype"_ls;
-static const auto FormattedBodyKeyL = "formatted_body"_ls;
-
-static const auto TextTypeKey = "m.text";
-static const auto EmoteTypeKey = "m.emote";
-static const auto NoticeTypeKey = "m.notice";
-
-static const auto HtmlContentTypeId = QStringLiteral("org.matrix.custom.html");
+namespace { // Supporting internal definitions
+constexpr auto RelatesToKey = "m.relates_to"_ls;
+constexpr auto MsgTypeKey = "msgtype"_ls;
+constexpr auto FormattedBodyKey = "formatted_body"_ls;
+constexpr auto TextTypeKey = "m.text"_ls;
+constexpr auto EmoteTypeKey = "m.emote"_ls;
+constexpr auto NoticeTypeKey = "m.notice"_ls;
+constexpr auto HtmlContentTypeId = "org.matrix.custom.html"_ls;
 
 template <typename ContentT>
 TypedBase* make(const QJsonObject& json)
@@ -38,13 +38,13 @@ TypedBase* make(const QJsonObject& json)
 template <>
 TypedBase* make<TextContent>(const QJsonObject& json)
 {
-    return json.contains(FormattedBodyKeyL) || json.contains(RelatesToKeyL)
+    return json.contains(FormattedBodyKey) || json.contains(RelatesToKey)
                ? new TextContent(json)
                : nullptr;
 }
 
 struct MsgTypeDesc {
-    QString matrixType;
+    QLatin1String matrixType;
     MsgType enumType;
     TypedBase* (*maker)(const QJsonObject&);
 };
@@ -53,11 +53,11 @@ const std::vector<MsgTypeDesc> msgTypes = {
     { TextTypeKey, MsgType::Text, make<TextContent> },
     { EmoteTypeKey, MsgType::Emote, make<TextContent> },
     { NoticeTypeKey, MsgType::Notice, make<TextContent> },
-    { QStringLiteral("m.image"), MsgType::Image, make<ImageContent> },
-    { QStringLiteral("m.file"), MsgType::File, make<FileContent> },
-    { QStringLiteral("m.location"), MsgType::Location, make<LocationContent> },
-    { QStringLiteral("m.video"), MsgType::Video, make<VideoContent> },
-    { QStringLiteral("m.audio"), MsgType::Audio, make<AudioContent> }
+    { "m.image"_ls, MsgType::Image, make<ImageContent> },
+    { "m.file"_ls, MsgType::File, make<FileContent> },
+    { "m.location"_ls, MsgType::Location, make<LocationContent> },
+    { "m.video"_ls, MsgType::Video, make<VideoContent> },
+    { "m.audio"_ls, MsgType::Audio, make<AudioContent> }
 };
 
 QString msgTypeToJson(MsgType enumType)
@@ -84,41 +84,44 @@ MsgType jsonToMsgType(const QString& matrixType)
     return MsgType::Unknown;
 }
 
-inline bool isReplacement(const Omittable<RelatesTo>& rel)
+inline bool isReplacement(const Omittable<EventRelation>& rel)
 {
-    return rel && rel->type == RelatesTo::ReplacementTypeId();
+    return rel && rel->type == EventRelation::ReplacementType;
 }
 
+} // anonymous namespace
+
 QJsonObject RoomMessageEvent::assembleContentJson(const QString& plainBody,
                                                   const QString& jsonMsgType,
                                                   TypedBase* content)
 {
-    auto json = content ? content->toJson() : QJsonObject();
-    if (json.contains(RelatesToKeyL)) {
+    QJsonObject json;
+    if (content) {
+        // TODO: replace with content->fillJson(json) when it starts working
+        json = content->toJson();
         if (jsonMsgType != TextTypeKey && jsonMsgType != NoticeTypeKey
             && jsonMsgType != EmoteTypeKey) {
-            json.remove(RelatesToKeyL);
-            qCWarning(EVENTS)
-                << RelatesToKeyL << "cannot be used in" << jsonMsgType
-                << "messages; the relation has been stripped off";
-        } else {
-            // After the above, we know for sure that the content is TextContent
-            // and that its RelatesTo structure is not omitted
-            auto* textContent = static_cast<const TextContent*>(content);
-            Q_ASSERT(textContent && textContent->relatesTo.has_value());
-            if (textContent->relatesTo->type == RelatesTo::ReplacementTypeId()) {
-                auto newContentJson = json.take("m.new_content"_ls).toObject();
-                newContentJson.insert(BodyKey, plainBody);
-                newContentJson.insert(MsgTypeKeyL, jsonMsgType);
-                json.insert(QStringLiteral("m.new_content"), newContentJson);
-                json[MsgTypeKeyL] = jsonMsgType;
-                json[BodyKeyL] = "* " + plainBody;
-                return json;
+            if (json.contains(RelatesToKey)) {
+                json.remove(RelatesToKey);
+                qCWarning(EVENTS)
+                    << RelatesToKey << "cannot be used in" << jsonMsgType
+                    << "messages; the relation has been stripped off";
             }
+        } else if (auto* textContent = static_cast<const TextContent*>(content);
+                   textContent->relatesTo
+                   && textContent->relatesTo->type
+                          == EventRelation::ReplacementType) {
+            auto newContentJson = json.take("m.new_content"_ls).toObject();
+            newContentJson.insert(BodyKey, plainBody);
+            newContentJson.insert(MsgTypeKey, jsonMsgType);
+            json.insert(QStringLiteral("m.new_content"), newContentJson);
+            json[MsgTypeKey] = jsonMsgType;
+            json[BodyKeyL] = "* " + plainBody;
+            return json;
         }
     }
-    json.insert(QStringLiteral("msgtype"), jsonMsgType);
-    json.insert(QStringLiteral("body"), plainBody);
+    json.insert(MsgTypeKey, jsonMsgType);
+    json.insert(BodyKey, plainBody);
     return json;
 }
 
@@ -177,8 +180,8 @@ RoomMessageEvent::RoomMessageEvent(const QJsonObject& obj)
     if (isRedacted())
         return;
     const QJsonObject content = contentJson();
-    if (content.contains(MsgTypeKeyL) && content.contains(BodyKeyL)) {
-        auto msgtype = content[MsgTypeKeyL].toString();
+    if (content.contains(MsgTypeKey) && content.contains(BodyKeyL)) {
+        auto msgtype = content[MsgTypeKey].toString();
         bool msgTypeFound = false;
         for (const auto& mt : msgTypes)
             if (mt.matrixType == msgtype) {
@@ -204,7 +207,7 @@ RoomMessageEvent::MsgType RoomMessageEvent::msgtype() const
 
 QString RoomMessageEvent::rawMsgtype() const
 {
-    return contentPart<QString>(MsgTypeKeyL);
+    return contentPart<QString>(MsgTypeKey);
 }
 
 QString RoomMessageEvent::plainBody() const
@@ -267,7 +270,7 @@ QString RoomMessageEvent::rawMsgTypeForFile(const QFileInfo& fi)
 }
 
 TextContent::TextContent(QString text, const QString& contentType,
-                         Omittable<RelatesTo> relatesTo)
+                         Omittable<EventRelation> relatesTo)
     : mimeType(QMimeDatabase().mimeTypeForName(contentType))
     , body(std::move(text))
     , relatesTo(std::move(relatesTo))
@@ -276,26 +279,8 @@ TextContent::TextContent(QString text, const QString& contentType,
         mimeType = QMimeDatabase().mimeTypeForName("text/html");
 }
 
-namespace Quotient {
-// Overload the default fromJson<> logic that defined in converters.h
-// as we want
-template <>
-Omittable<RelatesTo> fromJson(const QJsonValue& jv)
-{
-    const auto jo = jv.toObject();
-    if (jo.isEmpty())
-        return none;
-    const auto replyJson = jo.value(RelatesTo::ReplyTypeId()).toObject();
-    if (!replyJson.isEmpty())
-        return replyTo(fromJson<QString>(replyJson[EventIdKeyL]));
-
-    return RelatesTo { jo.value("rel_type"_ls).toString(),
-                       jo.value(EventIdKeyL).toString() };
-}
-} // namespace Quotient
-
 TextContent::TextContent(const QJsonObject& json)
-    : relatesTo(fromJson<Omittable<RelatesTo>>(json[RelatesToKeyL]))
+    : relatesTo(fromJson<Omittable<EventRelation>>(json[RelatesToKey]))
 {
     QMimeDatabase db;
     static const auto PlainTextMimeType = db.mimeTypeForName("text/plain");
@@ -308,7 +293,7 @@ TextContent::TextContent(const QJsonObject& json)
     // of sending HTML messages.
     if (actualJson["format"_ls].toString() == HtmlContentTypeId) {
         mimeType = HtmlMimeType;
-        body = actualJson[FormattedBodyKeyL].toString();
+        body = actualJson[FormattedBodyKey].toString();
     } else {
         // Falling back to plain text, as there's no standard way to describe
         // rich text in messages.
@@ -320,7 +305,6 @@ TextContent::TextContent(const QJsonObject& json)
 void TextContent::fillJson(QJsonObject* json) const
 {
     static const auto FormatKey = QStringLiteral("format");
-    static const auto FormattedBodyKey = QStringLiteral("formatted_body");
 
     Q_ASSERT(json);
     if (mimeType.inherits("text/html")) {
@@ -328,12 +312,15 @@ void TextContent::fillJson(QJsonObject* json) const
         json->insert(FormattedBodyKey, body);
     }
     if (relatesTo) {
-        json->insert(QStringLiteral("m.relates_to"),
-                     relatesTo->type == RelatesTo::ReplyTypeId() ?
-                         QJsonObject { { relatesTo->type, QJsonObject{ { EventIdKey, relatesTo->eventId } } } } :
-                         QJsonObject { { "rel_type", relatesTo->type }, { EventIdKey, relatesTo->eventId } }
-        );
-        if (relatesTo->type == RelatesTo::ReplacementTypeId()) {
+        json->insert(
+            QStringLiteral("m.relates_to"),
+            relatesTo->type == EventRelation::ReplyType
+                ? QJsonObject { { relatesTo->type,
+                                  QJsonObject {
+                                      { EventIdKey, relatesTo->eventId } } } }
+                : QJsonObject { { RelTypeKey, relatesTo->type },
+                                { EventIdKey, relatesTo->eventId } });
+        if (relatesTo->type == EventRelation::ReplacementType) {
             QJsonObject newContentJson;
             if (mimeType.inherits("text/html")) {
                 newContentJson.insert(FormatKey, HtmlContentTypeId);
diff --git a/lib/events/roommessageevent.h b/lib/events/roommessageevent.h
index 56597ddc..03a51328 100644
--- a/lib/events/roommessageevent.h
+++ b/lib/events/roommessageevent.h
@@ -6,6 +6,7 @@
 #pragma once
 
 #include "eventcontent.h"
+#include "eventrelation.h"
 #include "roomevent.h"
 
 class QFileInfo;
@@ -16,7 +17,7 @@ namespace MessageEventContent = EventContent; // Back-compatibility
 /**
  * The event class corresponding to m.room.message events
  */
-class RoomMessageEvent : public RoomEvent {
+class QUOTIENT_API RoomMessageEvent : public RoomEvent {
     Q_GADGET
 public:
     DEFINE_EVENT_TYPEID("m.room.message", RoomMessageEvent)
@@ -97,40 +98,42 @@ REGISTER_EVENT_TYPE(RoomMessageEvent)
 using MessageEventType = RoomMessageEvent::MsgType;
 
 namespace EventContent {
-    // Additional event content types
 
-    struct RelatesTo {
-        static constexpr const char* ReplyTypeId() { return "m.in_reply_to"; }
-        static constexpr const char* ReplacementTypeId() { return "m.replace"; }
-        QString type; // The only supported relation so far
-        QString eventId;
+    struct [[deprecated("Use Quotient::EventRelation instead")]] RelatesTo
+        : EventRelation {
+        static constexpr auto ReplyTypeId() { return ReplyType; }
+        static constexpr auto ReplacementTypeId() { return ReplacementType; }
     };
-    inline RelatesTo replyTo(QString eventId)
+    [[deprecated("Use EventRelation::replyTo() instead")]]
+    inline auto replyTo(QString eventId)
     {
-        return { RelatesTo::ReplyTypeId(), std::move(eventId) };
+        return EventRelation::replyTo(std::move(eventId));
     }
-    inline RelatesTo replacementOf(QString eventId)
+    [[deprecated("Use EventRelation::replace() instead")]]
+    inline auto replacementOf(QString eventId)
     {
-        return { RelatesTo::ReplacementTypeId(), std::move(eventId) };
+        return EventRelation::replace(std::move(eventId));
     }
 
+    // Additional event content types
+
     /**
      * Rich text content for m.text, m.emote, m.notice
      *
      * Available fields: mimeType, body. The body can be either rich text
      * or plain text, depending on what mimeType specifies.
      */
-    class TextContent : public TypedBase {
+    class QUOTIENT_API TextContent : public TypedBase {
     public:
         TextContent(QString text, const QString& contentType,
-                    Omittable<RelatesTo> relatesTo = none);
+                    Omittable<EventRelation> relatesTo = none);
         explicit TextContent(const QJsonObject& json);
 
         QMimeType type() const override { return mimeType; }
 
         QMimeType mimeType;
         QString body;
-        Omittable<RelatesTo> relatesTo;
+        Omittable<EventRelation> relatesTo;
 
     protected:
         void fillJson(QJsonObject* json) const override;
@@ -149,7 +152,7 @@ namespace EventContent {
      *   - thumbnail.mimeType
      *   - thumbnail.imageSize
      */
-    class LocationContent : public TypedBase {
+    class QUOTIENT_API LocationContent : public TypedBase {
     public:
         LocationContent(const QString& geoUri, const Thumbnail& thumbnail = {});
         explicit LocationContent(const QJsonObject& json);
@@ -168,7 +171,7 @@ namespace EventContent {
      * A base class for info types that include duration: audio and video
      */
     template <typename ContentT>
-    class PlayableContent : public ContentT {
+    class QUOTIENT_API PlayableContent : public ContentT {
     public:
         using ContentT::ContentT;
         PlayableContent(const QJsonObject& json)
diff --git a/lib/events/roompowerlevelsevent.h b/lib/events/roompowerlevelsevent.h
index 0346fc0d..415cc814 100644
--- a/lib/events/roompowerlevelsevent.h
+++ b/lib/events/roompowerlevelsevent.h
@@ -7,7 +7,7 @@
 #include "stateevent.h"
 
 namespace Quotient {
-class PowerLevelsEventContent : public EventContent::Base {
+class QUOTIENT_API PowerLevelsEventContent : public EventContent::Base {
 public:
     struct Notifications {
         int room;
@@ -34,11 +34,14 @@ protected:
     void fillJson(QJsonObject* o) const override;
 };
 
-class RoomPowerLevelsEvent : public StateEvent<PowerLevelsEventContent> {
-    Q_GADGET
+class QUOTIENT_API RoomPowerLevelsEvent
+    : public StateEvent<PowerLevelsEventContent> {
 public:
     DEFINE_EVENT_TYPEID("m.room.power_levels", RoomPowerLevelsEvent)
 
+    explicit RoomPowerLevelsEvent(PowerLevelsEventContent&& content)
+        : StateEvent(typeId(), matrixTypeId(), QString(), std::move(content))
+    {}
     explicit RoomPowerLevelsEvent(const QJsonObject& obj)
         : StateEvent(typeId(), obj)
     {}
@@ -61,9 +64,6 @@ public:
     int powerLevelForEvent(const QString& eventId) const;
     int powerLevelForState(const QString& eventId) const;
     int powerLevelForUser(const QString& userId) const;
-
-private:
 };
-
 REGISTER_EVENT_TYPE(RoomPowerLevelsEvent)
 } // namespace Quotient
diff --git a/lib/events/roomtombstoneevent.h b/lib/events/roomtombstoneevent.h
index 30e53738..15d26923 100644
--- a/lib/events/roomtombstoneevent.h
+++ b/lib/events/roomtombstoneevent.h
@@ -6,11 +6,10 @@
 #include "stateevent.h"
 
 namespace Quotient {
-class RoomTombstoneEvent : public StateEventBase {
+class QUOTIENT_API RoomTombstoneEvent : public StateEventBase {
 public:
     DEFINE_EVENT_TYPEID("m.room.tombstone", RoomTombstoneEvent)
 
-    explicit RoomTombstoneEvent() : StateEventBase(typeId(), matrixTypeId()) {}
     explicit RoomTombstoneEvent(const QJsonObject& obj)
         : StateEventBase(typeId(), obj)
     {}
diff --git a/lib/events/simplestateevents.h b/lib/events/simplestateevents.h
index cf1bfbba..9610574b 100644
--- a/lib/events/simplestateevents.h
+++ b/lib/events/simplestateevents.h
@@ -8,8 +8,7 @@
 namespace Quotient {
 namespace EventContent {
     template <typename T>
-    class SimpleContent {
-    public:
+    struct SimpleContent {
         using value_type = T;
 
         // The constructor is templated to enable perfect forwarding
@@ -25,20 +24,17 @@ namespace EventContent {
             return { { key, Quotient::toJson(value) } };
         }
 
-    public:
         T value;
-
-    protected:
-        QString key;
+        const QString key;
     };
 } // namespace EventContent
 
 #define DEFINE_SIMPLE_STATE_EVENT(_Name, _TypeId, _ValueType, _ContentKey)     \
-    class _Name : public StateEvent<EventContent::SimpleContent<_ValueType>> { \
+    class QUOTIENT_API _Name                                                \
+        : public StateEvent<EventContent::SimpleContent<_ValueType>> {         \
     public:                                                                    \
         using value_type = content_type::value_type;                           \
         DEFINE_EVENT_TYPEID(_TypeId, _Name)                                    \
-        explicit _Name() : _Name(value_type()) {}                              \
         template <typename T>                                                  \
         explicit _Name(T&& value)                                              \
             : StateEvent(typeId(), matrixTypeId(), QString(),                  \
@@ -55,6 +51,7 @@ namespace EventContent {
 
 DEFINE_SIMPLE_STATE_EVENT(RoomNameEvent, "m.room.name", QString, name)
 DEFINE_SIMPLE_STATE_EVENT(RoomTopicEvent, "m.room.topic", QString, topic)
+DEFINE_SIMPLE_STATE_EVENT(RoomPinnedEvent, "m.room.pinned_messages", QStringList, pinnedEvents)
 
 class [[deprecated(
     "m.room.aliases events are deprecated by the Matrix spec; use"
@@ -65,10 +62,6 @@ public:
     explicit RoomAliasesEvent(const QJsonObject& obj)
         : StateEvent(typeId(), obj, QStringLiteral("aliases"))
     {}
-    RoomAliasesEvent(const QString& server, const QStringList& aliases)
-        : StateEvent(typeId(), matrixTypeId(), server,
-                     QStringLiteral("aliases"), aliases)
-    {}
     QString server() const { return stateKey(); }
     QStringList aliases() const { return content().value; }
 };
diff --git a/lib/events/stateevent.cpp b/lib/events/stateevent.cpp
index efe011a0..e53d47d4 100644
--- a/lib/events/stateevent.cpp
+++ b/lib/events/stateevent.cpp
@@ -5,20 +5,13 @@
 
 using namespace Quotient;
 
-// Aside from the normal factory to instantiate StateEventBase inheritors
-// StateEventBase itself can be instantiated if there's a state_key JSON key
-// but the event type is unknown.
-[[maybe_unused]] static auto stateEventTypeInitialised =
-    RoomEvent::factory_t::addMethod(
-        [](const QJsonObject& json, const QString& matrixType) -> StateEventPtr {
-            if (!json.contains(StateKeyKeyL))
-                return nullptr;
-
-            if (auto e = StateEventBase::factory_t::make(json, matrixType))
-                return e;
-
-            return makeEvent<StateEventBase>(unknownEventTypeId(), json);
-        });
+StateEventBase::StateEventBase(Type type, const QJsonObject& json)
+    : RoomEvent(json.contains(StateKeyKeyL) ? type : unknownEventTypeId(), json)
+{
+    if (Event::type() == unknownEventTypeId() && !json.contains(StateKeyKeyL))
+        qWarning(EVENTS) << "Attempt to create a state event with no stateKey -"
+                            "forcing the event type to unknown to avoid damage";
+}
 
 StateEventBase::StateEventBase(Event::Type type, event_mtype_t matrixType,
                                const QString& stateKey,
diff --git a/lib/events/stateevent.h b/lib/events/stateevent.h
index b0aa9907..88da68f8 100644
--- a/lib/events/stateevent.h
+++ b/lib/events/stateevent.h
@@ -17,12 +17,11 @@ inline QJsonObject basicStateEventJson(const QString& matrixTypeId,
              { ContentKey, content } };
 }
 
-class StateEventBase : public RoomEvent {
+class QUOTIENT_API StateEventBase : public RoomEvent {
 public:
-    using factory_t = EventFactory<StateEventBase>;
+    static inline EventFactory<StateEventBase> factory { "StateEvent" };
 
-    StateEventBase(Type type, const QJsonObject& json) : RoomEvent(type, json)
-    {}
+    StateEventBase(Type type, const QJsonObject& json);
     StateEventBase(Type type, event_mtype_t matrixType,
                    const QString& stateKey = {},
                    const QJsonObject& contentJson = {});
@@ -37,6 +36,22 @@ public:
 using StateEventPtr = event_ptr_tt<StateEventBase>;
 using StateEvents = EventsArray<StateEventBase>;
 
+//! \brief Override RoomEvent factory with that from StateEventBase if JSON has
+//! stateKey
+//!
+//! This means in particular that an event with a type known to RoomEvent but
+//! having stateKey set (even to an empty value) will be treated as a state
+//! event and most likely end up as unknown (consider, e.g., m.room.message
+//! that has stateKey set).
+template <>
+inline RoomEventPtr doLoadEvent(const QJsonObject& json,
+                                const QString& matrixType)
+{
+    if (json.contains(StateKeyKeyL))
+        return StateEventBase::factory.loadEvent(json, matrixType);
+    return RoomEvent::factory.loadEvent(json, matrixType);
+}
+
 template <>
 inline bool is<StateEventBase>(const Event& e)
 {
diff --git a/lib/events/stickerevent.h b/lib/events/stickerevent.h
index 93671086..0957dca3 100644
--- a/lib/events/stickerevent.h
+++ b/lib/events/stickerevent.h
@@ -11,7 +11,7 @@ namespace Quotient {
 /// Sticker messages are specialised image messages that are displayed without
 /// controls (e.g. no "download" link, or light-box view on click, as would be
 /// displayed for for m.image events).
-class StickerEvent : public RoomEvent
+class QUOTIENT_API StickerEvent : public RoomEvent
 {
 public:
     DEFINE_EVENT_TYPEID("m.sticker", StickerEvent)
diff --git a/lib/events/typingevent.h b/lib/events/typingevent.h
index 7456100a..522f7e42 100644
--- a/lib/events/typingevent.h
+++ b/lib/events/typingevent.h
@@ -6,7 +6,7 @@
 #include "event.h"
 
 namespace Quotient {
-class TypingEvent : public Event {
+class QUOTIENT_API TypingEvent : public Event {
 public:
     DEFINE_EVENT_TYPEID("m.typing", TypingEvent)