Move SecurityPolicy, TrustLevel intro extra headers

This avoids the need to include the whole TrustStorage in files like
SendStanzaParams.h.

11 files changed, 161 insertions, 96 deletions

diff --git a/src/client/QXmppAtmManager.cpp b/src/client/QXmppAtmManager.cpp
index b7ea5660..4ea30cae 100644
--- a/src/client/QXmppAtmManager.cpp
+++ b/src/client/QXmppAtmManager.cpp
@@ -13,6 +13,7 @@
 #include "QXmppTrustMessageKeyOwner.h"
 #include "QXmppUtils.h"
 
+using namespace QXmpp;
 using namespace QXmpp::Private;
 
 ///
@@ -79,10 +80,10 @@ QFuture<void> QXmppAtmManager::makeTrustDecisions(const QString &encryption, con
 {
     QFutureInterface<void> interface(QFutureInterfaceBase::Started);
 
-    auto future = keys(encryption, QXmppTrustStorage::Authenticated | QXmppTrustStorage::ManuallyDistrusted);
-    await(future, this, [=](const QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QByteArray>> &&keys) mutable {
-        const auto authenticatedKeys = keys.value(QXmppTrustStorage::Authenticated);
-        const auto manuallyDistrustedKeys = keys.value(QXmppTrustStorage::ManuallyDistrusted);
+    auto future = keys(encryption, TrustLevel::Authenticated | TrustLevel::ManuallyDistrusted);
+    await(future, this, [=](QHash<TrustLevel, QMultiHash<QString, QByteArray>> keys) mutable {
+        const auto authenticatedKeys = keys.value(TrustLevel::Authenticated);
+        const auto manuallyDistrustedKeys = keys.value(TrustLevel::ManuallyDistrusted);
         const auto ownJid = client()->configuration().jidBare();
         const auto ownAuthenticatedKeys = authenticatedKeys.values(ownJid);
 
@@ -303,7 +304,7 @@ QFuture<void> QXmppAtmManager::handleMessage(const QXmppMessage &message)
 
         auto future = trustLevel(encryption, senderJid, senderKey);
         await(future, this, [=](const auto &&senderKeyTrustLevel) mutable {
-            const auto isSenderKeyAuthenticated = senderKeyTrustLevel == QXmppTrustStorage::Authenticated;
+            const auto isSenderKeyAuthenticated = senderKeyTrustLevel == TrustLevel::Authenticated;
 
             // key owner JIDs mapped to key IDs
             QMultiHash<QString, QByteArray> keysBeingAuthenticated;
@@ -380,11 +381,11 @@ QFuture<void> QXmppAtmManager::authenticate(const QString &encryption, const QMu
 
     QFutureInterface<void> interface(QFutureInterfaceBase::Started);
 
-    auto future = setTrustLevel(encryption, keyIds, QXmppTrustStorage::Authenticated);
+    auto future = setTrustLevel(encryption, keyIds, TrustLevel::Authenticated);
     await(future, this, [=]() mutable {
         auto future = securityPolicy(encryption);
         await(future, this, [=](auto securityPolicy) mutable {
-            if (securityPolicy == QXmppTrustStorage::Toakafa) {
+            if (securityPolicy == Toakafa) {
                 auto future = distrustAutomaticallyTrustedKeys(encryption, keyIds.uniqueKeys());
                 await(future, this, [=]() mutable {
                     auto future = makePostponedTrustDecisions(encryption, keyIds.values());
@@ -418,7 +419,7 @@ QFuture<void> QXmppAtmManager::distrust(const QString &encryption, const QMultiH
 
     QFutureInterface<void> interface(QFutureInterfaceBase::Started);
 
-    auto future = setTrustLevel(encryption, keyIds, QXmppTrustStorage::ManuallyDistrusted);
+    auto future = setTrustLevel(encryption, keyIds, TrustLevel::ManuallyDistrusted);
     await(future, this, [=]() mutable {
         auto future = trustStorage()->removeKeysForPostponedTrustDecisions(encryption, keyIds.values());
         await(future, this, [=]() mutable {
@@ -438,7 +439,7 @@ QFuture<void> QXmppAtmManager::distrust(const QString &encryption, const QMultiH
 ///
 QFuture<void> QXmppAtmManager::distrustAutomaticallyTrustedKeys(const QString &encryption, const QList<QString> &keyOwnerJids)
 {
-    return setTrustLevel(encryption, keyOwnerJids, QXmppTrustStorage::AutomaticallyTrusted, QXmppTrustStorage::AutomaticallyDistrusted);
+    return setTrustLevel(encryption, keyOwnerJids, TrustLevel::AutomaticallyTrusted, TrustLevel::AutomaticallyDistrusted);
 }
 
 ///
diff --git a/src/client/QXmppSendStanzaParams.cpp b/src/client/QXmppSendStanzaParams.cpp
index 6c8b6ccc..9711750d 100644
--- a/src/client/QXmppSendStanzaParams.cpp
+++ b/src/client/QXmppSendStanzaParams.cpp
@@ -6,6 +6,8 @@
 
 #include <QVector>
 
+using namespace QXmpp;
+
 ///
 /// \class QXmppSendStanzaParams
 ///
@@ -17,8 +19,8 @@
 class QXmppSendStanzaParamsPrivate : public QSharedData
 {
 public:
+    TrustLevels acceptedTrustLevels;
     QVector<QString> encryptionJids;
-    QXmppTrustStorage::TrustLevels acceptedTrustLevels;
 };
 
 QXmppSendStanzaParams::QXmppSendStanzaParams()
@@ -65,7 +67,7 @@ void QXmppSendStanzaParams::setEncryptionJids(QVector<QString> encryptionJids)
 ///
 /// \return the trust levels of the keys used for encryption
 ///
-std::optional<QXmppTrustStorage::TrustLevels> QXmppSendStanzaParams::acceptedTrustLevels() const
+std::optional<TrustLevels> QXmppSendStanzaParams::acceptedTrustLevels() const
 {
     if (d->acceptedTrustLevels) {
         return d->acceptedTrustLevels;
@@ -80,7 +82,7 @@ std::optional<QXmppTrustStorage::TrustLevels> QXmppSendStanzaParams::acceptedTru
 ///
 /// \param trustLevels trust levels of the keys used for encryption
 ///
-void QXmppSendStanzaParams::setAcceptedTrustLevels(std::optional<QXmppTrustStorage::TrustLevels> trustLevels)
+void QXmppSendStanzaParams::setAcceptedTrustLevels(std::optional<TrustLevels> trustLevels)
 {
-    d->acceptedTrustLevels = trustLevels.value_or(QXmppTrustStorage::TrustLevels());
+    d->acceptedTrustLevels = trustLevels.value_or(QXmpp::TrustLevels());
 }
diff --git a/src/client/QXmppSendStanzaParams.h b/src/client/QXmppSendStanzaParams.h
index 70ef572a..56bb314b 100644
--- a/src/client/QXmppSendStanzaParams.h
+++ b/src/client/QXmppSendStanzaParams.h
@@ -6,7 +6,7 @@
 #define QXMPPSENDSTANZAPARAMS_H
 
 #include "QXmppGlobal.h"
-#include "QXmppTrustStorage.h"
+#include "QXmppTrustLevel.h"
 
 #include <optional>
 
@@ -27,8 +27,8 @@ public:
     QVector<QString> encryptionJids() const;
     void setEncryptionJids(QVector<QString>);
 
-    std::optional<QXmppTrustStorage::TrustLevels> acceptedTrustLevels() const;
-    void setAcceptedTrustLevels(std::optional<QXmppTrustStorage::TrustLevels> trustLevels);
+    std::optional<QXmpp::TrustLevels> acceptedTrustLevels() const;
+    void setAcceptedTrustLevels(std::optional<QXmpp::TrustLevels> trustLevels);
 
 private:
     QSharedDataPointer<QXmppSendStanzaParamsPrivate> d;
diff --git a/src/client/QXmppTrustLevel.h b/src/client/QXmppTrustLevel.h
new file mode 100644
index 00000000..2cff9e2a
--- /dev/null
+++ b/src/client/QXmppTrustLevel.h
@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
+//
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#ifndef QXMPPTRUSTLEVEL_H
+#define QXMPPTRUSTLEVEL_H
+
+#include <QFlags>
+#include <QHashFunctions>
+
+namespace QXmpp {
+
+///
+/// Trust level of public long-term keys used by end-to-end encryption
+/// protocols
+///
+/// \since QXmpp 1.5
+///
+enum class TrustLevel {
+    /// The key's trust is not decided.
+    Undecided = 1,
+    /// The key is automatically distrusted (e.g., by the security policy TOAKAFA).
+    /// \see SecurityPolicy
+    AutomaticallyDistrusted = 2,
+    /// The key is manually distrusted (e.g., by clicking a button or \xep{0450, Automatic Trust
+    /// Management (ATM)}).
+    ManuallyDistrusted = 4,
+    /// The key is automatically trusted (e.g., by the client for all keys of a bare JID until one
+    /// of it is authenticated).
+    AutomaticallyTrusted = 8,
+    /// The key is manually trusted (e.g., by clicking a button).
+    ManuallyTrusted = 16,
+    /// The key is authenticated (e.g., by QR code scanning or \xep{0450, Automatic Trust
+    /// Management (ATM)}).
+    Authenticated = 32,
+};
+
+Q_DECLARE_FLAGS(TrustLevels, TrustLevel)
+Q_DECLARE_OPERATORS_FOR_FLAGS(TrustLevels)
+
+}  // namespace QXmpp
+
+/// \cond
+// Scoped enums (enum class) are not implicitly converted to int
+inline uint qHash(QXmpp::TrustLevel key, uint seed) noexcept { return qHash(std::underlying_type_t<QXmpp::TrustLevel>(key), seed); }
+/// \endcond
+
+#endif  // QXMPPTRUSTLEVEL_H
diff --git a/src/client/QXmppTrustManager.cpp b/src/client/QXmppTrustManager.cpp
index e198255c..7b9b34ab 100644
--- a/src/client/QXmppTrustManager.cpp
+++ b/src/client/QXmppTrustManager.cpp
@@ -5,7 +5,9 @@
 #include "QXmppTrustManager.h"
 
 #include "QXmppFutureUtils_p.h"
+#include "QXmppTrustStorage.h"
 
+using namespace QXmpp;
 using namespace QXmpp::Private;
 
 ///
@@ -38,7 +40,7 @@ QXmppTrustManager::~QXmppTrustManager() = default;
 /// \param encryption encryption protocol namespace
 /// \param securityPolicy security policy being applied
 ///
-QFuture<void> QXmppTrustManager::setSecurityPolicy(const QString &encryption, QXmppTrustStorage::SecurityPolicy securityPolicy)
+QFuture<void> QXmppTrustManager::setSecurityPolicy(const QString &encryption, TrustSecurityPolicy securityPolicy)
 {
     return m_trustStorage->setSecurityPolicy(encryption, securityPolicy);
 }
@@ -60,7 +62,7 @@ QFuture<void> QXmppTrustManager::resetSecurityPolicy(const QString &encryption)
 ///
 /// \return the set security policy
 ///
-QFuture<QXmppTrustStorage::SecurityPolicy> QXmppTrustManager::securityPolicy(const QString &encryption)
+QFuture<TrustSecurityPolicy> QXmppTrustManager::securityPolicy(const QString &encryption)
 {
     return m_trustStorage->securityPolicy(encryption);
 }
@@ -109,7 +111,7 @@ QFuture<QByteArray> QXmppTrustManager::ownKey(const QString &encryption)
 /// \param keyIds IDs of the keys
 /// \param trustLevel trust level of the keys
 ///
-QFuture<void> QXmppTrustManager::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, QXmppTrustStorage::TrustLevel trustLevel)
+QFuture<void> QXmppTrustManager::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, TrustLevel trustLevel)
 {
     return m_trustStorage->addKeys(encryption, keyOwnerJid, keyIds, trustLevel);
 }
@@ -157,7 +159,7 @@ QFuture<void> QXmppTrustManager::removeKeys(const QString &encryption)
 ///
 /// \return the key owner JIDs mapped to their keys with specific trust levels
 ///
-QFuture<QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QByteArray>>> QXmppTrustManager::keys(const QString &encryption, QXmppTrustStorage::TrustLevels trustLevels)
+QFuture<QHash<QXmpp::TrustLevel, QMultiHash<QString, QByteArray>>> QXmppTrustManager::keys(const QString &encryption, QXmpp::TrustLevels trustLevels)
 {
     return m_trustStorage->keys(encryption, trustLevels);
 }
@@ -175,7 +177,7 @@ QFuture<QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QByteArray>>> Q
 ///
 /// \return the key IDs mapped to their trust levels for specific key owners
 ///
-QFuture<QHash<QString, QHash<QByteArray, QXmppTrustStorage::TrustLevel>>> QXmppTrustManager::keys(const QString &encryption, const QList<QString> &keyOwnerJids, QXmppTrustStorage::TrustLevels trustLevels)
+QFuture<QHash<QString, QHash<QByteArray, QXmpp::TrustLevel>>> QXmppTrustManager::keys(const QString &encryption, const QList<QString> &keyOwnerJids, QXmpp::TrustLevels trustLevels)
 {
     return m_trustStorage->keys(encryption, keyOwnerJids, trustLevels);
 }
@@ -190,7 +192,7 @@ QFuture<QHash<QString, QHash<QByteArray, QXmppTrustStorage::TrustLevel>>> QXmppT
 ///
 /// \return whether a key of the key owner with a passed trust level is stored
 ///
-QFuture<bool> QXmppTrustManager::hasKey(const QString &encryption, const QString &keyOwnerJid, QXmppTrustStorage::TrustLevels trustLevels)
+QFuture<bool> QXmppTrustManager::hasKey(const QString &encryption, const QString &keyOwnerJid, TrustLevels trustLevels)
 {
     return m_trustStorage->hasKey(encryption, keyOwnerJid, trustLevels);
 }
@@ -204,7 +206,7 @@ QFuture<bool> QXmppTrustManager::hasKey(const QString &encryption, const QString
 /// \param keyIds key owners' bare JIDs mapped to the IDs of their keys
 /// \param trustLevel trust level being set
 ///
-QFuture<void> QXmppTrustManager::setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, QXmppTrustStorage::TrustLevel trustLevel)
+QFuture<void> QXmppTrustManager::setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, TrustLevel trustLevel)
 {
     QFutureInterface<void> interface(QFutureInterfaceBase::Started);
 
@@ -225,7 +227,7 @@ QFuture<void> QXmppTrustManager::setTrustLevel(const QString &encryption, const
 /// \param oldTrustLevel trust level being changed
 /// \param newTrustLevel trust level being set
 ///
-QFuture<void> QXmppTrustManager::setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, QXmppTrustStorage::TrustLevel oldTrustLevel, QXmppTrustStorage::TrustLevel newTrustLevel)
+QFuture<void> QXmppTrustManager::setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, TrustLevel oldTrustLevel, TrustLevel newTrustLevel)
 {
     QFutureInterface<void> interface(QFutureInterfaceBase::Started);
 
@@ -249,7 +251,7 @@ QFuture<void> QXmppTrustManager::setTrustLevel(const QString &encryption, const
 ///
 /// \return the key's trust level
 ///
-QFuture<QXmppTrustStorage::TrustLevel> QXmppTrustManager::trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId)
+QFuture<TrustLevel> QXmppTrustManager::trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId)
 {
     return m_trustStorage->trustLevel(encryption, keyOwnerJid, keyId);
 }
diff --git a/src/client/QXmppTrustManager.h b/src/client/QXmppTrustManager.h
index 9081af92..601bb9ac 100644
--- a/src/client/QXmppTrustManager.h
+++ b/src/client/QXmppTrustManager.h
@@ -6,7 +6,12 @@
 #define QXMPPTRUSTMANAGER_H
 
 #include "QXmppClientExtension.h"
-#include "QXmppTrustStorage.h"
+#include "QXmppTrustLevel.h"
+#include "QXmppTrustSecurityPolicy.h"
+
+#include <QFuture>
+
+class QXmppTrustStorage;
 
 class QXMPP_EXPORT QXmppTrustManager : public QXmppClientExtension
 {
@@ -16,25 +21,25 @@ public:
     QXmppTrustManager(QXmppTrustStorage *trustStorage);
     ~QXmppTrustManager();
 
-    QFuture<void> setSecurityPolicy(const QString &encryption, QXmppTrustStorage::SecurityPolicy securityPolicy);
+    QFuture<void> setSecurityPolicy(const QString &encryption, QXmpp::TrustSecurityPolicy securityPolicy);
     QFuture<void> resetSecurityPolicy(const QString &encryption);
-    QFuture<QXmppTrustStorage::SecurityPolicy> securityPolicy(const QString &encryption);
+    QFuture<QXmpp::TrustSecurityPolicy> securityPolicy(const QString &encryption);
 
     QFuture<void> setOwnKey(const QString &encryption, const QByteArray &keyId);
     QFuture<void> resetOwnKey(const QString &encryption);
     QFuture<QByteArray> ownKey(const QString &encryption);
 
-    QFuture<void> addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, QXmppTrustStorage::TrustLevel trustLevel = QXmppTrustStorage::AutomaticallyDistrusted);
+    QFuture<void> addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, QXmpp::TrustLevel trustLevel = QXmpp::TrustLevel::AutomaticallyDistrusted);
     QFuture<void> removeKeys(const QString &encryption, const QList<QByteArray> &keyIds);
     QFuture<void> removeKeys(const QString &encryption, const QString &keyOwnerJid);
     QFuture<void> removeKeys(const QString &encryption);
-    QFuture<QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QByteArray>>> keys(const QString &encryption, QXmppTrustStorage::TrustLevels trustLevels = {});
-    QFuture<QHash<QString, QHash<QByteArray, QXmppTrustStorage::TrustLevel>>> keys(const QString &encryption, const QList<QString> &keyOwnerJids, QXmppTrustStorage::TrustLevels trustLevels = {});
-    QFuture<bool> hasKey(const QString &encryption, const QString &keyOwnerJid, QXmppTrustStorage::TrustLevels trustLevels);
+    QFuture<QHash<QXmpp::TrustLevel, QMultiHash<QString, QByteArray>>> keys(const QString &encryption, QXmpp::TrustLevels trustLevels = {});
+    QFuture<QHash<QString, QHash<QByteArray, QXmpp::TrustLevel>>> keys(const QString &encryption, const QList<QString> &keyOwnerJids, QXmpp::TrustLevels trustLevels = {});
+    QFuture<bool> hasKey(const QString &encryption, const QString &keyOwnerJid, QXmpp::TrustLevels trustLevels);
 
-    QFuture<void> setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, QXmppTrustStorage::TrustLevel trustLevel);
-    QFuture<void> setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, QXmppTrustStorage::TrustLevel oldTrustLevel, QXmppTrustStorage::TrustLevel newTrustLevel);
-    QFuture<QXmppTrustStorage::TrustLevel> trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId);
+    QFuture<void> setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, QXmpp::TrustLevel trustLevel);
+    QFuture<void> setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, QXmpp::TrustLevel oldTrustLevel, QXmpp::TrustLevel newTrustLevel);
+    QFuture<QXmpp::TrustLevel> trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId);
 
     QFuture<void> resetAll(const QString &encryption);
 
diff --git a/src/client/QXmppTrustMemoryStorage.cpp b/src/client/QXmppTrustMemoryStorage.cpp
index a94768d2..daab2e73 100644
--- a/src/client/QXmppTrustMemoryStorage.cpp
+++ b/src/client/QXmppTrustMemoryStorage.cpp
@@ -6,6 +6,7 @@
 
 #include "QXmppFutureUtils_p.h"
 
+using namespace QXmpp;
 using namespace QXmpp::Private;
 
 ///
@@ -23,14 +24,14 @@ struct Key
 {
     QByteArray id;
     QString ownerJid;
-    QXmppTrustStorage::TrustLevel trustLevel;
+    TrustLevel trustLevel;
 };
 
 class QXmppTrustMemoryStoragePrivate
 {
 public:
     // encryption protocols mapped to security policies
-    QMap<QString, QXmppTrustStorage::SecurityPolicy> securityPolicies;
+    QMap<QString, TrustSecurityPolicy> securityPolicies;
 
     // encryption protocols mapped to keys of this client instance
     QMap<QString, QByteArray> ownKeys;
@@ -50,7 +51,7 @@ QXmppTrustMemoryStorage::QXmppTrustMemoryStorage()
 QXmppTrustMemoryStorage::~QXmppTrustMemoryStorage() = default;
 
 /// \cond
-QFuture<void> QXmppTrustMemoryStorage::setSecurityPolicy(const QString &encryption, QXmppTrustStorage::SecurityPolicy securityPolicy)
+QFuture<void> QXmppTrustMemoryStorage::setSecurityPolicy(const QString &encryption, TrustSecurityPolicy securityPolicy)
 {
     d->securityPolicies.insert(encryption, securityPolicy);
     return makeReadyFuture();
@@ -62,7 +63,7 @@ QFuture<void> QXmppTrustMemoryStorage::resetSecurityPolicy(const QString &encryp
     return makeReadyFuture();
 }
 
-QFuture<QXmppTrustStorage::SecurityPolicy> QXmppTrustMemoryStorage::securityPolicy(const QString &encryption)
+QFuture<TrustSecurityPolicy> QXmppTrustMemoryStorage::securityPolicy(const QString &encryption)
 {
     return makeReadyFuture(std::move(d->securityPolicies.value(encryption)));
 }
@@ -85,7 +86,7 @@ QFuture<QByteArray> QXmppTrustMemoryStorage::ownKey(const QString &encryption)
     return makeReadyFuture(std::move(key));
 }
 
-QFuture<void> QXmppTrustMemoryStorage::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, QXmppTrustStorage::TrustLevel trustLevel)
+QFuture<void> QXmppTrustMemoryStorage::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, TrustLevel trustLevel)
 {
     for (const auto &keyId : keyIds) {
         Key key;
@@ -132,7 +133,7 @@ QFuture<void> QXmppTrustMemoryStorage::removeKeys(const QString &encryption)
     return makeReadyFuture();
 }
 
-QFuture<QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QByteArray>>> QXmppTrustMemoryStorage::keys(const QString &encryption, TrustLevels trustLevels)
+QFuture<QHash<TrustLevel, QMultiHash<QString, QByteArray>>> QXmppTrustMemoryStorage::keys(const QString &encryption, TrustLevels trustLevels)
 {
     QHash<TrustLevel, QMultiHash<QString, QByteArray>> keys;
 
@@ -147,9 +148,9 @@ QFuture<QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QByteArray>>> Q
     return makeReadyFuture(std::move(keys));
 }
 
-QFuture<QHash<QString, QHash<QByteArray, QXmppTrustStorage::TrustLevel>>> QXmppTrustMemoryStorage::keys(const QString &encryption, const QList<QString> &keyOwnerJids, TrustLevels trustLevels)
+QFuture<QHash<QString, QHash<QByteArray, TrustLevel>>> QXmppTrustMemoryStorage::keys(const QString &encryption, const QList<QString> &keyOwnerJids, TrustLevels trustLevels)
 {
-    QHash<QString, QHash<QByteArray, QXmppTrustStorage::TrustLevel>> keys;
+    QHash<QString, QHash<QByteArray, TrustLevel>> keys;
 
     const auto storedKeys = d->keys.values(encryption);
     for (const auto &key : storedKeys) {
@@ -231,7 +232,7 @@ QFuture<QHash<QString, QMultiHash<QString, QByteArray>>> QXmppTrustMemoryStorage
     return makeReadyFuture(std::move(modifiedKeys));
 }
 
-QFuture<QXmppTrustStorage::TrustLevel> QXmppTrustMemoryStorage::trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId)
+QFuture<TrustLevel> QXmppTrustMemoryStorage::trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId)
 {
     const auto keys = d->keys.values(encryption);
     for (const auto &key : keys) {
@@ -240,7 +241,7 @@ QFuture<QXmppTrustStorage::TrustLevel> QXmppTrustMemoryStorage::trustLevel(const
         }
     }
 
-    return makeReadyFuture(std::move(QXmppTrustStorage::Undecided));
+    return makeReadyFuture(std::move(TrustLevel::Undecided));
 }
 
 QFuture<void> QXmppTrustMemoryStorage::resetAll(const QString &encryption)
diff --git a/src/client/QXmppTrustMemoryStorage.h b/src/client/QXmppTrustMemoryStorage.h
index 1d0e2561..f5e92569 100644
--- a/src/client/QXmppTrustMemoryStorage.h
+++ b/src/client/QXmppTrustMemoryStorage.h
@@ -18,25 +18,25 @@ public:
     ~QXmppTrustMemoryStorage();
 
     /// \cond
-    QFuture<void> setSecurityPolicy(const QString &encryption, SecurityPolicy securityPolicy) override;
+    QFuture<void> setSecurityPolicy(const QString &encryption, QXmpp::TrustSecurityPolicy securityPolicy) override;
     QFuture<void> resetSecurityPolicy(const QString &encryption) override;
-    QFuture<SecurityPolicy> securityPolicy(const QString &encryption) override;
+    QFuture<QXmpp::TrustSecurityPolicy> securityPolicy(const QString &encryption) override;
 
     QFuture<void> setOwnKey(const QString &encryption, const QByteArray &keyId) override;
     QFuture<void> resetOwnKey(const QString &encryption) override;
     QFuture<QByteArray> ownKey(const QString &encryption) override;
 
-    QFuture<void> addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, TrustLevel trustLevel = TrustLevel::AutomaticallyDistrusted) override;
+    QFuture<void> addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, QXmpp::TrustLevel trustLevel = QXmpp::TrustLevel::AutomaticallyDistrusted) override;
     QFuture<void> removeKeys(const QString &encryption, const QList<QByteArray> &keyIds) override;
     QFuture<void> removeKeys(const QString &encryption, const QString &keyOwnerJid) override;
     QFuture<void> removeKeys(const QString &encryption) override;
-    QFuture<QHash<TrustLevel, QMultiHash<QString, QByteArray>>> keys(const QString &encryption, TrustLevels trustLevels = {}) override;
-    QFuture<QHash<QString, QHash<QByteArray, TrustLevel>>> keys(const QString &encryption, const QList<QString> &keyOwnerJids, TrustLevels trustLevels = {}) override;
-    QFuture<bool> hasKey(const QString &encryption, const QString &keyOwnerJid, TrustLevels trustLevels) override;
+    QFuture<QHash<QXmpp::TrustLevel, QMultiHash<QString, QByteArray>>> keys(const QString &encryption, QXmpp::TrustLevels trustLevels = {}) override;
+    QFuture<QHash<QString, QHash<QByteArray, QXmpp::TrustLevel>>> keys(const QString &encryption, const QList<QString> &keyOwnerJids, QXmpp::TrustLevels trustLevels = {}) override;
+    QFuture<bool> hasKey(const QString &encryption, const QString &keyOwnerJid, QXmpp::TrustLevels trustLevels) override;
 
-    QFuture<QHash<QString, QMultiHash<QString, QByteArray>>> setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, TrustLevel trustLevel) override;
-    QFuture<QHash<QString, QMultiHash<QString, QByteArray>>> setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, TrustLevel oldTrustLevel, TrustLevel newTrustLevel) override;
-    QFuture<TrustLevel> trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId) override;
+    QFuture<QHash<QString, QMultiHash<QString, QByteArray>>> setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, QXmpp::TrustLevel trustLevel) override;
+    QFuture<QHash<QString, QMultiHash<QString, QByteArray>>> setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, QXmpp::TrustLevel oldTrustLevel, QXmpp::TrustLevel newTrustLevel) override;
+    QFuture<QXmpp::TrustLevel> trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId) override;
 
     QFuture<void> resetAll(const QString &encryption) override;
     /// \endcond
diff --git a/src/client/QXmppTrustSecurityPolicy.h b/src/client/QXmppTrustSecurityPolicy.h
new file mode 100644
index 00000000..5020b81d
--- /dev/null
+++ b/src/client/QXmppTrustSecurityPolicy.h
@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
+//
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#ifndef QXMPPTRUSTSECURITYPOLICY_H
+#define QXMPPTRUSTSECURITYPOLICY_H
+
+#include <QMetaType>
+
+namespace QXmpp {
+
+///
+/// Security policy to decide which public long-term keys are used for encryption because they are
+/// trusted
+///
+/// \since QXmpp 1.5
+///
+enum TrustSecurityPolicy {
+    /// New keys must be trusted manually.
+    NoSecurityPolicy,
+    /// New keys are trusted automatically until the first authentication but automatically
+    /// distrusted afterwards. \see \xep{0450, Automatic Trust Management (ATM)}
+    Toakafa,
+};
+
+}  // namespace QXmpp
+
+Q_DECLARE_METATYPE(QXmpp::TrustSecurityPolicy)
+
+#endif  // QXMPPTRUSTSECURITYPOLICY_H
diff --git a/src/client/QXmppTrustStorage.cpp b/src/client/QXmppTrustStorage.cpp
index 18637fab..50b39089 100644
--- a/src/client/QXmppTrustStorage.cpp
+++ b/src/client/QXmppTrustStorage.cpp
@@ -15,7 +15,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::setSecurityPolicy(const QString &encryption, SecurityPolicy securityPolicy)
+/// \fn QXmppTrustStorage::setSecurityPolicy(const QString &encryption, QXmpp::SecurityPolicy securityPolicy)
 ///
 /// Sets the security policy for an encryption protocol.
 ///
@@ -72,7 +72,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, QXmppTrustStorage::TrustLevel trustLevel)
+/// \fn QXmppTrustStorage::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, QXmpp::TrustLevel trustLevel)
 ///
 /// Adds keys.
 ///
@@ -109,7 +109,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::keys(const QString &encryption, TrustLevels trustLevels = {})
+/// \fn QXmppTrustStorage::keys(const QString &encryption, QXmpp::TrustLevels trustLevels = {})
 ///
 /// Returns the JIDs of all key owners mapped to the IDs of their keys with
 /// specific trust levels.
@@ -123,7 +123,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::keys(const QString &encryption, const QList<QString> &keyOwnerJids, TrustLevels trustLevels = {})
+/// \fn QXmppTrustStorage::keys(const QString &encryption, const QList<QString> &keyOwnerJids, QXmpp::TrustLevels trustLevels = {})
 ///
 /// Returns the IDs of keys mapped to their trust levels for specific key
 /// owners.
@@ -139,7 +139,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::hasKey(const QString &encryption, const QString &keyOwnerJid, TrustLevels trustLevels)
+/// \fn QXmppTrustStorage::hasKey(const QString &encryption, const QString &keyOwnerJid, QXmpp::TrustLevels trustLevels)
 ///
 /// Returns whether at least one key of a key owner with a specific trust level
 /// is stored.
@@ -152,7 +152,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, TrustLevel trustLevel)
+/// \fn QXmppTrustStorage::setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, QXmpp::TrustLevel trustLevel)
 ///
 /// Sets the trust level of keys.
 ///
@@ -167,7 +167,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, TrustLevel oldTrustLevel, TrustLevel newTrustLevel)
+/// \fn QXmppTrustStorage::setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, QXmpp::TrustLevel oldTrustLevel, QXmpp::TrustLevel newTrustLevel)
 ///
 /// Sets the trust level of keys specified by their key owner and trust level.
 ///
diff --git a/src/client/QXmppTrustStorage.h b/src/client/QXmppTrustStorage.h
index b93eae7b..0edc92a4 100644
--- a/src/client/QXmppTrustStorage.h
+++ b/src/client/QXmppTrustStorage.h
@@ -6,61 +6,37 @@
 #define QXMPPTRUSTSTORAGE_H
 
 #include "QXmppGlobal.h"
+#include "QXmppTrustLevel.h"
+#include "QXmppTrustSecurityPolicy.h"
 
 #include <QFuture>
 
 class QXMPP_EXPORT QXmppTrustStorage
 {
 public:
-    ///
-    /// Security policy to decide which public long-term keys are used for
-    /// encryption because they are trusted
-    ///
-    enum SecurityPolicy {
-        NoSecurityPolicy,  ///< New keys must be trusted manually.
-        Toakafa,           ///< New keys are trusted automatically until the first authentication but automatically distrusted afterwards. \see \xep{0450, Automatic Trust Management (ATM)}
-    };
-
-    ///
-    /// Trust level of public long-term keys used by end-to-end encryption
-    /// protocols
-    ///
-    enum TrustLevel {
-        Undecided = 1,                ///< The key's trust is not decided.
-        AutomaticallyDistrusted = 2,  ///< The key is automatically distrusted (e.g., by the security policy TOAKAFA). \see SecurityPolicy
-        ManuallyDistrusted = 4,       ///< The key is manually distrusted (e.g., by clicking a button or \xep{0450, Automatic Trust Management (ATM)}).
-        AutomaticallyTrusted = 8,     ///< The key is automatically trusted (e.g., by the client for all keys of a bare JID until one of it is authenticated).
-        ManuallyTrusted = 16,         ///< The key is manually trusted (e.g., by clicking a button).
-        Authenticated = 32,           ///< The key is authenticated (e.g., by QR code scanning or \xep{0450, Automatic Trust Management (ATM)}).
-    };
-    Q_DECLARE_FLAGS(TrustLevels, TrustLevel)
-
     virtual ~QXmppTrustStorage() = default;
 
-    virtual QFuture<void> setSecurityPolicy(const QString &encryption, SecurityPolicy securityPolicy) = 0;
+    virtual QFuture<void> setSecurityPolicy(const QString &encryption, QXmpp::TrustSecurityPolicy securityPolicy) = 0;
     virtual QFuture<void> resetSecurityPolicy(const QString &encryption) = 0;
-    virtual QFuture<SecurityPolicy> securityPolicy(const QString &encryption) = 0;
+    virtual QFuture<QXmpp::TrustSecurityPolicy> securityPolicy(const QString &encryption) = 0;
 
     virtual QFuture<void> setOwnKey(const QString &encryption, const QByteArray &keyId) = 0;
     virtual QFuture<void> resetOwnKey(const QString &encryption) = 0;
     virtual QFuture<QByteArray> ownKey(const QString &encryption) = 0;
 
-    virtual QFuture<void> addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, TrustLevel trustLevel = TrustLevel::AutomaticallyDistrusted) = 0;
+    virtual QFuture<void> addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, QXmpp::TrustLevel trustLevel = QXmpp::TrustLevel::AutomaticallyDistrusted) = 0;
     virtual QFuture<void> removeKeys(const QString &encryption, const QList<QByteArray> &keyIds) = 0;
     virtual QFuture<void> removeKeys(const QString &encryption, const QString &keyOwnerJid) = 0;
     virtual QFuture<void> removeKeys(const QString &encryption) = 0;
-    virtual QFuture<QHash<TrustLevel, QMultiHash<QString, QByteArray>>> keys(const QString &encryption, TrustLevels trustLevels = {}) = 0;
-    virtual QFuture<QHash<QString, QHash<QByteArray, TrustLevel>>> keys(const QString &encryption, const QList<QString> &keyOwnerJids, TrustLevels trustLevels = {}) = 0;
-    virtual QFuture<bool> hasKey(const QString &encryption, const QString &keyOwnerJid, TrustLevels trustLevels) = 0;
+    virtual QFuture<QHash<QXmpp::TrustLevel, QMultiHash<QString, QByteArray>>> keys(const QString &encryption, QXmpp::TrustLevels trustLevels = {}) = 0;
+    virtual QFuture<QHash<QString, QHash<QByteArray, QXmpp::TrustLevel>>> keys(const QString &encryption, const QList<QString> &keyOwnerJids, QXmpp::TrustLevels trustLevels = {}) = 0;
+    virtual QFuture<bool> hasKey(const QString &encryption, const QString &keyOwnerJid, QXmpp::TrustLevels trustLevels) = 0;
 
-    virtual QFuture<QHash<QString, QMultiHash<QString, QByteArray>>> setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, TrustLevel trustLevel) = 0;
-    virtual QFuture<QHash<QString, QMultiHash<QString, QByteArray>>> setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, TrustLevel oldTrustLevel, TrustLevel newTrustLevel) = 0;
-    virtual QFuture<TrustLevel> trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId) = 0;
+    virtual QFuture<QHash<QString, QMultiHash<QString, QByteArray>>> setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, QXmpp::TrustLevel trustLevel) = 0;
+    virtual QFuture<QHash<QString, QMultiHash<QString, QByteArray>>> setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, QXmpp::TrustLevel oldTrustLevel, QXmpp::TrustLevel newTrustLevel) = 0;
+    virtual QFuture<QXmpp::TrustLevel> trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId) = 0;
 
     virtual QFuture<void> resetAll(const QString &encryption) = 0;
 };
 
-Q_DECLARE_METATYPE(QXmppTrustStorage::SecurityPolicy)
-Q_DECLARE_OPERATORS_FOR_FLAGS(QXmppTrustStorage::TrustLevels)
-
 #endif  // QXMPPTRUSTSTORAGE_H