Move SecurityPolicy, TrustLevel intro extra headers

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

2 files changed, 186 insertions, 182 deletions

diff --git a/tests/qxmppatmmanager/tst_qxmppatmmanager.cpp b/tests/qxmppatmmanager/tst_qxmppatmmanager.cpp
index 944321f9..ad29d7ea 100644
--- a/tests/qxmppatmmanager/tst_qxmppatmmanager.cpp
+++ b/tests/qxmppatmmanager/tst_qxmppatmmanager.cpp
@@ -15,6 +15,8 @@
 #include <QObject>
 #include <QSet>
 
+using namespace QXmpp;
+
 Q_DECLARE_METATYPE(QList<QXmppTrustMessageKeyOwner>)
 
 // time period (in ms) to wait for a trust message that should not be sent.
@@ -211,13 +213,13 @@ void tst_QXmppAtmManager::testMakePostponedTrustDecisions()
                                                             QByteArray::fromBase64(QByteArrayLiteral("3bqdCfhQalsOp3LcrFVucCQB4pRRWCyoBTV8KM/oOhY=")) } };
 
     auto future = m_manager.keys(ns_omemo,
-                                 QXmppTrustStorage::Authenticated);
+                                 TrustLevel::Authenticated);
     QVERIFY(future.isFinished());
     auto result = future.result();
     QCOMPARE(
         result,
         QHash({ std::pair(
-            QXmppTrustStorage::Authenticated,
+            TrustLevel::Authenticated,
             authenticatedKeys) }));
 
     QMultiHash<QString, QByteArray> manuallyDistrustedKeys = { { QStringLiteral("alice@example.org"),
@@ -230,13 +232,13 @@ void tst_QXmppAtmManager::testMakePostponedTrustDecisions()
                                                                  QByteArray::fromBase64(QByteArrayLiteral("U3+UnkTp12gusKbzWwN0lqDLEPb2CdMxP4bY85q9pxA=")) } };
 
     future = m_manager.keys(ns_omemo,
-                            QXmppTrustStorage::ManuallyDistrusted);
+                            TrustLevel::ManuallyDistrusted);
     QVERIFY(future.isFinished());
     result = future.result();
     QCOMPARE(
         result,
         QHash({ std::pair(
-            QXmppTrustStorage::ManuallyDistrusted,
+            TrustLevel::ManuallyDistrusted,
             manuallyDistrustedKeys) }));
 }
 
@@ -249,25 +251,25 @@ void tst_QXmppAtmManager::testDistrustAutomaticallyTrustedKeys()
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("RwyI/3m9l4wgju9JduFxb5MEJvBNRDfPfo1Ewhl1DEI=")),
           QByteArray::fromBase64(QByteArrayLiteral("tfskruc1xcfC+VKzuqvLZUJVZccZX/Pg5j88ukpuY2M=")) },
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("GaHysNhcfDSzG2q6OAThRGUpuFB9E7iCRR/1mK1TL+Q=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("dZVdoBINK2n8BkWeTzVg0lVOah4n/9IA/IvQpzUuo1w=")) },
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("We+r1A/kixDad8e383oTmhPDy8g+F5/ircMJmEET8MA=")) },
-        QXmppTrustStorage::ManuallyTrusted);
+        TrustLevel::ManuallyTrusted);
 
     m_manager.distrustAutomaticallyTrustedKeys(ns_omemo,
                                                { QStringLiteral("alice@example.org"),
@@ -281,13 +283,13 @@ void tst_QXmppAtmManager::testDistrustAutomaticallyTrustedKeys()
                                                                       QByteArray::fromBase64(QByteArrayLiteral("dZVdoBINK2n8BkWeTzVg0lVOah4n/9IA/IvQpzUuo1w=")) } };
 
     auto future = m_manager.keys(ns_omemo,
-                                 QXmppTrustStorage::AutomaticallyDistrusted);
+                                 TrustLevel::AutomaticallyDistrusted);
     QVERIFY(future.isFinished());
     auto result = future.result();
     QCOMPARE(
         result,
         QHash({ std::pair(
-            QXmppTrustStorage::AutomaticallyDistrusted,
+            TrustLevel::AutomaticallyDistrusted,
             automaticallyDistrustedKeys) }));
 }
 
@@ -304,7 +306,7 @@ void tst_QXmppAtmManager::testDistrust()
         ns_omemo,
         QStringLiteral("alice@example.org"),
         authenticatedKeys.values(),
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     QMultiHash<QString, QByteArray> automaticallyTrustedKeys = { { QStringLiteral("bob@example.com"),
                                                                    QByteArray::fromBase64(QByteArrayLiteral("mwT0Hwr7aG1p+x0q60H0UDSEnr8cr7hxvxDEhFGrLmY=")) } };
@@ -313,7 +315,7 @@ void tst_QXmppAtmManager::testDistrust()
         ns_omemo,
         QStringLiteral("bob@example.com"),
         automaticallyTrustedKeys.values(),
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     QMultiHash<QString, QByteArray> manuallyDistrustedKeys = { { QStringLiteral("alice@example.org"),
                                                                  QByteArray::fromBase64(QByteArrayLiteral("6FjJDKcwUxncGka8RvrTGSho+LVDX/7E0+pi5ueqOBQ=")) },
@@ -324,7 +326,7 @@ void tst_QXmppAtmManager::testDistrust()
         ns_omemo,
         QStringLiteral("alice@example.org"),
         manuallyDistrustedKeys.values(),
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     QXmppTrustMessageKeyOwner keyOwnerAlice;
     keyOwnerAlice.setJid(QStringLiteral("alice@example.org"));
@@ -362,13 +364,13 @@ void tst_QXmppAtmManager::testDistrust()
     QCOMPARE(
         result,
         QHash({ std::pair(
-                    QXmppTrustStorage::Authenticated,
+                    TrustLevel::Authenticated,
                     authenticatedKeys),
                 std::pair(
-                    QXmppTrustStorage::AutomaticallyTrusted,
+                    TrustLevel::AutomaticallyTrusted,
                     automaticallyTrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::ManuallyDistrusted,
+                    TrustLevel::ManuallyDistrusted,
                     manuallyDistrustedKeys) }));
 
     futureVoid = m_manager.distrust(ns_omemo,
@@ -400,10 +402,10 @@ void tst_QXmppAtmManager::testDistrust()
     QCOMPARE(
         result,
         QHash({ std::pair(
-                    QXmppTrustStorage::Authenticated,
+                    TrustLevel::Authenticated,
                     authenticatedKeys),
                 std::pair(
-                    QXmppTrustStorage::ManuallyDistrusted,
+                    TrustLevel::ManuallyDistrusted,
                     manuallyDistrustedKeys) }));
 
     auto futurePostponed = m_trustStorage.keysForPostponedTrustDecisions(ns_omemo,
@@ -434,20 +436,20 @@ void tst_QXmppAtmManager::testDistrust()
 
 void tst_QXmppAtmManager::testAuthenticate_data()
 {
-    QTest::addColumn<QXmppTrustStorage::SecurityPolicy>("securityPolicy");
+    QTest::addColumn<TrustSecurityPolicy>("securityPolicy");
 
     QTest::newRow("noSecurityPolicy")
-        << QXmppTrustStorage::NoSecurityPolicy;
+        << NoSecurityPolicy;
 
     QTest::newRow("toakafa")
-        << QXmppTrustStorage::Toakafa;
+        << Toakafa;
 }
 
 void tst_QXmppAtmManager::testAuthenticate()
 {
     clearTrustStorage();
 
-    QFETCH(QXmppTrustStorage::SecurityPolicy, securityPolicy);
+    QFETCH(TrustSecurityPolicy, securityPolicy);
     m_manager.setSecurityPolicy(ns_omemo, securityPolicy);
 
     QMultiHash<QString, QByteArray> authenticatedKeys = { { QStringLiteral("alice@example.org"),
@@ -459,13 +461,13 @@ void tst_QXmppAtmManager::testAuthenticate()
         ns_omemo,
         QStringLiteral("alice@example.org"),
         authenticatedKeys.values(QStringLiteral("alice@example.org")),
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("carol@example.net"),
         authenticatedKeys.values(QStringLiteral("carol@example.net")),
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     QMultiHash<QString, QByteArray> automaticallyTrustedKeys = { { QStringLiteral("bob@example.com"),
                                                                    QByteArray::fromBase64(QByteArrayLiteral("mwT0Hwr7aG1p+x0q60H0UDSEnr8cr7hxvxDEhFGrLmY=")) },
@@ -476,7 +478,7 @@ void tst_QXmppAtmManager::testAuthenticate()
         ns_omemo,
         QStringLiteral("bob@example.com"),
         automaticallyTrustedKeys.values(),
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     QMultiHash<QString, QByteArray> manuallyDistrustedKeys = { { QStringLiteral("alice@example.org"),
                                                                  QByteArray::fromBase64(QByteArrayLiteral("6FjJDKcwUxncGka8RvrTGSho+LVDX/7E0+pi5ueqOBQ=")) },
@@ -487,7 +489,7 @@ void tst_QXmppAtmManager::testAuthenticate()
         ns_omemo,
         QStringLiteral("alice@example.org"),
         manuallyDistrustedKeys.values(),
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     QMultiHash<QString, QByteArray> automaticallyDistrustedKeys = { { QStringLiteral("alice@example.org"),
                                                                       QByteArray::fromBase64(QByteArrayLiteral("RwyI/3m9l4wgju9JduFxb5MEJvBNRDfPfo1Ewhl1DEI=")) },
@@ -498,7 +500,7 @@ void tst_QXmppAtmManager::testAuthenticate()
         ns_omemo,
         QStringLiteral("alice@example.org"),
         automaticallyDistrustedKeys.values(),
-        QXmppTrustStorage::AutomaticallyDistrusted);
+        TrustLevel::AutomaticallyDistrusted);
 
     QXmppTrustMessageKeyOwner keyOwnerAlice;
     keyOwnerAlice.setJid(QStringLiteral("alice@example.org"));
@@ -562,16 +564,16 @@ void tst_QXmppAtmManager::testAuthenticate()
     QCOMPARE(
         result,
         QHash({ std::pair(
-                    QXmppTrustStorage::Authenticated,
+                    TrustLevel::Authenticated,
                     authenticatedKeys),
                 std::pair(
-                    QXmppTrustStorage::AutomaticallyTrusted,
+                    TrustLevel::AutomaticallyTrusted,
                     automaticallyTrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::ManuallyDistrusted,
+                    TrustLevel::ManuallyDistrusted,
                     manuallyDistrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::AutomaticallyDistrusted,
+                    TrustLevel::AutomaticallyDistrusted,
                     automaticallyDistrustedKeys) }));
 
     futureVoid = m_manager.authenticate(ns_omemo,
@@ -613,13 +615,13 @@ void tst_QXmppAtmManager::testAuthenticate()
                                { QStringLiteral("carol@example.net"),
                                  QByteArray::fromBase64(QByteArrayLiteral("+CQZlFyxdeTGgbPby7YvvZT3YIVcIi+1E8N5nSc6QTA=")) } };
 
-    if (securityPolicy == QXmppTrustStorage::NoSecurityPolicy) {
+    if (securityPolicy == NoSecurityPolicy) {
         automaticallyDistrustedKeys = { { QStringLiteral("alice@example.org"),
                                           QByteArray::fromBase64(QByteArrayLiteral("tfskruc1xcfC+VKzuqvLZUJVZccZX/Pg5j88ukpuY2M=")) } };
 
         automaticallyTrustedKeys = { { QStringLiteral("bob@example.com"),
                                        QByteArray::fromBase64(QByteArrayLiteral("/dqv0+RNyFIPdMQiJ7mSEJWKVExFeUBEvTXxOtqIMDg=")) } };
-    } else if (securityPolicy == QXmppTrustStorage::Toakafa) {
+    } else if (securityPolicy == Toakafa) {
         automaticallyDistrustedKeys = { { QStringLiteral("alice@example.org"),
                                           QByteArray::fromBase64(QByteArrayLiteral("tfskruc1xcfC+VKzuqvLZUJVZccZX/Pg5j88ukpuY2M=")) },
                                         { QStringLiteral("bob@example.com"),
@@ -630,33 +632,33 @@ void tst_QXmppAtmManager::testAuthenticate()
     QVERIFY(future.isFinished());
     result = future.result();
     switch (securityPolicy) {
-    case QXmppTrustStorage::NoSecurityPolicy:
+    case NoSecurityPolicy:
         QCOMPARE(
             result,
             QHash({ std::pair(
-                        QXmppTrustStorage::Authenticated,
+                        TrustLevel::Authenticated,
                         authenticatedKeys),
                     std::pair(
-                        QXmppTrustStorage::AutomaticallyTrusted,
+                        TrustLevel::AutomaticallyTrusted,
                         automaticallyTrustedKeys),
                     std::pair(
-                        QXmppTrustStorage::ManuallyDistrusted,
+                        TrustLevel::ManuallyDistrusted,
                         manuallyDistrustedKeys),
                     std::pair(
-                        QXmppTrustStorage::AutomaticallyDistrusted,
+                        TrustLevel::AutomaticallyDistrusted,
                         automaticallyDistrustedKeys) }));
         break;
-    case QXmppTrustStorage::Toakafa:
+    case Toakafa:
         QCOMPARE(
             result,
             QHash({ std::pair(
-                        QXmppTrustStorage::Authenticated,
+                        TrustLevel::Authenticated,
                         authenticatedKeys),
                     std::pair(
-                        QXmppTrustStorage::ManuallyDistrusted,
+                        TrustLevel::ManuallyDistrusted,
                         manuallyDistrustedKeys),
                     std::pair(
-                        QXmppTrustStorage::AutomaticallyDistrusted,
+                        TrustLevel::AutomaticallyDistrusted,
                         automaticallyDistrustedKeys) }));
         break;
     }
@@ -715,10 +717,10 @@ void tst_QXmppAtmManager::testMakeTrustDecisions()
     QCOMPARE(
         result,
         QHash({ std::pair(
-                    QXmppTrustStorage::Authenticated,
+                    TrustLevel::Authenticated,
                     keysBeingAuthenticated),
                 std::pair(
-                    QXmppTrustStorage::ManuallyDistrusted,
+                    TrustLevel::ManuallyDistrusted,
                     keysBeingDistrusted) }));
 }
 
@@ -850,7 +852,7 @@ void tst_QXmppAtmManager::testHandleMessage()
             m_manager.addKeys(ns_omemo,
                               senderJid,
                               { senderKey },
-                              QXmppTrustStorage::Authenticated);
+                              TrustLevel::Authenticated);
         } else {
             m_manager.addKeys(ns_omemo,
                               senderJid,
@@ -893,10 +895,10 @@ void tst_QXmppAtmManager::testHandleMessage()
                 QCOMPARE(
                     result,
                     QHash({ std::pair(
-                                QXmppTrustStorage::Authenticated,
+                                TrustLevel::Authenticated,
                                 authenticatedKeys),
                             std::pair(
-                                QXmppTrustStorage::ManuallyDistrusted,
+                                TrustLevel::ManuallyDistrusted,
                                 manuallyDistrustedKeys) }));
 
             } else {
@@ -918,10 +920,10 @@ void tst_QXmppAtmManager::testHandleMessage()
                 QCOMPARE(
                     result,
                     QHash({ std::pair(
-                                QXmppTrustStorage::Authenticated,
+                                TrustLevel::Authenticated,
                                 authenticatedKeys),
                             std::pair(
-                                QXmppTrustStorage::ManuallyDistrusted,
+                                TrustLevel::ManuallyDistrusted,
                                 manuallyDistrustedKeys) }));
             }
         } else {
@@ -1006,14 +1008,14 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsNoKeys()
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("RwyI/3m9l4wgju9JduFxb5MEJvBNRDfPfo1Ewhl1DEI=")),
           QByteArray::fromBase64(QByteArrayLiteral("tfskruc1xcfC+VKzuqvLZUJVZccZX/Pg5j88ukpuY2M=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     // key of contact's endpoints
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("8gBTC1fspYkO4akS6QKN+XFA9Nmf9NEIg7hjtlpTjII=")) },
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     const QObject context;
 
@@ -1048,10 +1050,10 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsNoKeys()
     QCOMPARE(
         result,
         QHash({ std::pair(
-                    QXmppTrustStorage::Authenticated,
+                    TrustLevel::Authenticated,
                     authenticatedKeys),
                 std::pair(
-                    QXmppTrustStorage::ManuallyDistrusted,
+                    TrustLevel::ManuallyDistrusted,
                     manuallyDistrustedKeys) }));
 }
 
@@ -1065,31 +1067,31 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsOwnKeys()
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("RwyI/3m9l4wgju9JduFxb5MEJvBNRDfPfo1Ewhl1DEI=")),
           QByteArray::fromBase64(QByteArrayLiteral("tfskruc1xcfC+VKzuqvLZUJVZccZX/Pg5j88ukpuY2M=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("GaHysNhcfDSzG2q6OAThRGUpuFB9E7iCRR/1mK1TL+Q=")) },
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     // keys of contact's endpoints
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("+1VJvMLCGvkDquZ6mQZ+SS+gTbQ436BJUwFOoW0Ma1g=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("8gBTC1fspYkO4akS6QKN+XFA9Nmf9NEIg7hjtlpTjII=")) },
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("carol@example.net"),
         { QByteArray::fromBase64(QByteArrayLiteral("tVy3ygBnW4q6V2TYe8p4i904zD+x4rNMRegxPnPI7fw=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     int sentMessagesCount = 0;
     const QObject context;
@@ -1221,14 +1223,14 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsOwnKeysNoOwnEndpoints()
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("+1VJvMLCGvkDquZ6mQZ+SS+gTbQ436BJUwFOoW0Ma1g=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("carol@example.net"),
         { QByteArray::fromBase64(QByteArrayLiteral("tVy3ygBnW4q6V2TYe8p4i904zD+x4rNMRegxPnPI7fw=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     int sentMessagesCount = 0;
     const QObject context;
@@ -1351,21 +1353,21 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsOwnKeysNoOwnEndpointsWithAuthent
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("GaHysNhcfDSzG2q6OAThRGUpuFB9E7iCRR/1mK1TL+Q=")) },
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("+1VJvMLCGvkDquZ6mQZ+SS+gTbQ436BJUwFOoW0Ma1g=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("carol@example.net"),
         { QByteArray::fromBase64(QByteArrayLiteral("tVy3ygBnW4q6V2TYe8p4i904zD+x4rNMRegxPnPI7fw=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     int sentMessagesCount = 0;
     const QObject context;
@@ -1493,14 +1495,14 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsOwnKeysNoContactsWithAuthenticat
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("RwyI/3m9l4wgju9JduFxb5MEJvBNRDfPfo1Ewhl1DEI=")),
           QByteArray::fromBase64(QByteArrayLiteral("tfskruc1xcfC+VKzuqvLZUJVZccZX/Pg5j88ukpuY2M=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     // keys of contact's endpoints
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("8gBTC1fspYkO4akS6QKN+XFA9Nmf9NEIg7hjtlpTjII=")) },
-        QXmppTrustStorage::AutomaticallyDistrusted);
+        TrustLevel::AutomaticallyDistrusted);
 
     int sentMessagesCount = 0;
     const QObject context;
@@ -1586,21 +1588,21 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsSoleOwnKeyDistrusted()
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("RwyI/3m9l4wgju9JduFxb5MEJvBNRDfPfo1Ewhl1DEI=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("+1VJvMLCGvkDquZ6mQZ+SS+gTbQ436BJUwFOoW0Ma1g=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("carol@example.net"),
         { QByteArray::fromBase64(QByteArrayLiteral("tVy3ygBnW4q6V2TYe8p4i904zD+x4rNMRegxPnPI7fw=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     int sentMessagesCount = 0;
     const QObject context;
@@ -1687,7 +1689,7 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsSoleOwnKeyDistrusted()
                                                  QByteArray::fromBase64(QByteArrayLiteral("RwyI/3m9l4wgju9JduFxb5MEJvBNRDfPfo1Ewhl1DEI=")));
     QVERIFY(futureTrustLevel.isFinished());
     auto result = futureTrustLevel.result();
-    QCOMPARE(result, QXmppTrustStorage::ManuallyDistrusted);
+    QCOMPARE(result, TrustLevel::ManuallyDistrusted);
 }
 
 void tst_QXmppAtmManager::testMakeTrustDecisionsContactKeys()
@@ -1702,12 +1704,12 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsContactKeys()
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("RwyI/3m9l4wgju9JduFxb5MEJvBNRDfPfo1Ewhl1DEI=")),
           QByteArray::fromBase64(QByteArrayLiteral("tfskruc1xcfC+VKzuqvLZUJVZccZX/Pg5j88ukpuY2M=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("GaHysNhcfDSzG2q6OAThRGUpuFB9E7iCRR/1mK1TL+Q=")) },
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     // keys of contact's endpoints
     m_manager.addKeys(
@@ -1715,19 +1717,19 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsContactKeys()
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("+1VJvMLCGvkDquZ6mQZ+SS+gTbQ436BJUwFOoW0Ma1g=")),
           QByteArray::fromBase64(QByteArrayLiteral("T+dplAB8tGSdbYBbRiOm/jrS+8CPuzGHrH8ZmbjyvPo=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("8gBTC1fspYkO4akS6QKN+XFA9Nmf9NEIg7hjtlpTjII=")) },
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("carol@example.net"),
         { QByteArray::fromBase64(QByteArrayLiteral("tVy3ygBnW4q6V2TYe8p4i904zD+x4rNMRegxPnPI7fw=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     int sentMessagesCount = 0;
     const QObject context;
@@ -1830,14 +1832,14 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsContactKeysNoOwnEndpoints()
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("+1VJvMLCGvkDquZ6mQZ+SS+gTbQ436BJUwFOoW0Ma1g=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("carol@example.net"),
         { QByteArray::fromBase64(QByteArrayLiteral("tVy3ygBnW4q6V2TYe8p4i904zD+x4rNMRegxPnPI7fw=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     const QObject context;
 
@@ -1873,21 +1875,21 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsContactKeysNoOwnEndpointsWithAut
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("GaHysNhcfDSzG2q6OAThRGUpuFB9E7iCRR/1mK1TL+Q=")) },
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("+1VJvMLCGvkDquZ6mQZ+SS+gTbQ436BJUwFOoW0Ma1g=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("carol@example.net"),
         { QByteArray::fromBase64(QByteArrayLiteral("tVy3ygBnW4q6V2TYe8p4i904zD+x4rNMRegxPnPI7fw=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     int sentMessagesCount = 0;
     const QObject context;
@@ -1957,21 +1959,21 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsSoleContactKeyDistrusted()
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("RwyI/3m9l4wgju9JduFxb5MEJvBNRDfPfo1Ewhl1DEI=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("+1VJvMLCGvkDquZ6mQZ+SS+gTbQ436BJUwFOoW0Ma1g=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     // key of contact's endpoint
     m_manager.addKeys(
         ns_omemo,
         QStringLiteral("carol@example.net"),
         { QByteArray::fromBase64(QByteArrayLiteral("tVy3ygBnW4q6V2TYe8p4i904zD+x4rNMRegxPnPI7fw=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     int sentMessagesCount = 0;
     const QObject context;
@@ -2031,7 +2033,7 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsSoleContactKeyDistrusted()
                                                        QByteArray::fromBase64(QByteArrayLiteral("+1VJvMLCGvkDquZ6mQZ+SS+gTbQ436BJUwFOoW0Ma1g=")));
     QVERIFY(futureTrustLevel.isFinished());
     const auto result = futureTrustLevel.result();
-    QCOMPARE(result, QXmppTrustStorage::ManuallyDistrusted);
+    QCOMPARE(result, TrustLevel::ManuallyDistrusted);
 }
 
 void tst_QXmppAtmManager::testMakeTrustDecisionsOwnKeysDone()
@@ -2041,21 +2043,21 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsOwnKeysDone()
                                        QByteArray::fromBase64(QByteArrayLiteral("0RcVsGk3LnpEFsqqztTzAgCDgVXlfa03paSqJFOOWOU=")));
     QVERIFY(future.isFinished());
     auto result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::Authenticated);
+    QCOMPARE(result, TrustLevel::Authenticated);
 
     future = m_manager.trustLevel(ns_omemo,
                                   QStringLiteral("alice@example.org"),
                                   QByteArray::fromBase64(QByteArrayLiteral("tYn/wcIOxBSoW4W1UfPr/zgbLipBK2KsFfC7F1bzut0=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::Authenticated);
+    QCOMPARE(result, TrustLevel::Authenticated);
 
     future = m_manager.trustLevel(ns_omemo,
                                   QStringLiteral("alice@example.org"),
                                   QByteArray::fromBase64(QByteArrayLiteral("4iBsyJPVAfNWM/OgyA9fasOvkJ8K1/0wuYpwVGw4Q5M=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::ManuallyDistrusted);
+    QCOMPARE(result, TrustLevel::ManuallyDistrusted);
 }
 
 void tst_QXmppAtmManager::testMakeTrustDecisionsContactKeysDone()
@@ -2065,21 +2067,21 @@ void tst_QXmppAtmManager::testMakeTrustDecisionsContactKeysDone()
                                        QByteArray::fromBase64(QByteArrayLiteral("+1VJvMLCGvkDquZ6mQZ+SS+gTbQ436BJUwFOoW0Ma1g=")));
     QVERIFY(future.isFinished());
     auto result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::Authenticated);
+    QCOMPARE(result, TrustLevel::Authenticated);
 
     future = m_manager.trustLevel(ns_omemo,
                                   QStringLiteral("bob@example.com"),
                                   QByteArray::fromBase64(QByteArrayLiteral("mzDeKTQBVm1cTmzF9DjCGKa14pDADZOVLT9Kh7CK7AM=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::Authenticated);
+    QCOMPARE(result, TrustLevel::Authenticated);
 
     future = m_manager.trustLevel(ns_omemo,
                                   QStringLiteral("bob@example.com"),
                                   QByteArray::fromBase64(QByteArrayLiteral("8gBTC1fspYkO4akS6QKN+XFA9Nmf9NEIg7hjtlpTjII=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::ManuallyDistrusted);
+    QCOMPARE(result, TrustLevel::ManuallyDistrusted);
 }
 
 void tst_QXmppAtmManager::clearTrustStorage()
diff --git a/tests/qxmpptrustmemorystorage/tst_qxmpptrustmemorystorage.cpp b/tests/qxmpptrustmemorystorage/tst_qxmpptrustmemorystorage.cpp
index e0fab420..6696081d 100644
--- a/tests/qxmpptrustmemorystorage/tst_qxmpptrustmemorystorage.cpp
+++ b/tests/qxmpptrustmemorystorage/tst_qxmpptrustmemorystorage.cpp
@@ -8,6 +8,8 @@
 
 #include "util.h"
 
+using namespace QXmpp;
+
 static const char *ns_ox = "urn:xmpp:openpgp:0";
 static const char *ns_omemo = "eu.siacs.conversations.axolotl";
 
@@ -37,26 +39,26 @@ void tst_QXmppTrustMemoryStorage::testSecurityPolicy()
     auto future = m_trustStorage.securityPolicy(ns_ox);
     QVERIFY(future.isFinished());
     auto result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::NoSecurityPolicy);
+    QCOMPARE(result, NoSecurityPolicy);
 
-    m_trustStorage.setSecurityPolicy(ns_omemo, QXmppTrustStorage::Toakafa);
+    m_trustStorage.setSecurityPolicy(ns_omemo, Toakafa);
 
     future = m_trustStorage.securityPolicy(ns_ox);
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::NoSecurityPolicy);
+    QCOMPARE(result, NoSecurityPolicy);
 
     future = m_trustStorage.securityPolicy(ns_omemo);
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::Toakafa);
+    QCOMPARE(result, Toakafa);
 
     m_trustStorage.resetSecurityPolicy(ns_omemo);
 
     future = m_trustStorage.securityPolicy(ns_omemo);
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::NoSecurityPolicy);
+    QCOMPARE(result, NoSecurityPolicy);
 }
 
 void tst_QXmppTrustMemoryStorage::testOwnKeys()
@@ -112,7 +114,7 @@ void tst_QXmppTrustMemoryStorage::testKeys()
 
     // no automatically trusted and authenticated OMEMO keys
     future = m_trustStorage.keys(ns_omemo,
-                                 QXmppTrustStorage::AutomaticallyTrusted | QXmppTrustStorage::Authenticated);
+                                 TrustLevel::AutomaticallyTrusted | TrustLevel::Authenticated);
     QVERIFY(future.isFinished());
     result = future.result();
     QVERIFY(result.isEmpty());
@@ -120,7 +122,7 @@ void tst_QXmppTrustMemoryStorage::testKeys()
     // no automatically trusted and authenticated OMEMO key from Alice
     auto futureBool = m_trustStorage.hasKey(ns_omemo,
                                             QStringLiteral("alice@example.org"),
-                                            QXmppTrustStorage::AutomaticallyTrusted | QXmppTrustStorage::Authenticated);
+                                            TrustLevel::AutomaticallyTrusted | TrustLevel::Authenticated);
     QVERIFY(futureBool.isFinished());
     auto resultBool = futureBool.result();
     QVERIFY(!resultBool);
@@ -136,39 +138,39 @@ void tst_QXmppTrustMemoryStorage::testKeys()
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("aFABnX7Q/rbTgjBySYzrT2FsYCVYb49mbca5yB734KQ=")) },
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("Ciemp4ZNzRJxnRD+k28vAie0kXJrwl4IrbfDy7n6OxE=")) },
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("rvSXBRd+EICMhQvVgcREQJxxP+T4EBmai4mYHBfJQGg=")) },
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("tCP1CI3pqSTVGzFYFyPYUMfMZ9Ck/msmfD0wH/VtJBM=")),
           QByteArray::fromBase64(QByteArrayLiteral("2fhJtrgoMJxfLI3084/YkYh9paqiSiLFDVL2m0qAgX4=")) },
-        QXmppTrustStorage::ManuallyTrusted);
+        TrustLevel::ManuallyTrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("YjVI04NcbTPvXLaA95RO84HPcSvyOgEZ2r5cTyUs0C8=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     m_trustStorage.addKeys(
         ns_ox,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("aFABnX7Q/rbTgjBySYzrT2FsYCVYb49mbca5yB734KQ=")),
           QByteArray::fromBase64(QByteArrayLiteral("IhpPjiKLchgrAG5cpSfTvdzPjZ5v6vTOluHEUehkgCA=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     QMultiHash<QString, QByteArray> automaticallyDistrustedKeys = { { QStringLiteral("alice@example.org"),
                                                                       QByteArray::fromBase64(QByteArrayLiteral("WaAnpWyW1hnFooH3oJo9Ba5XYoksnLPeJRTAjxPbv38=")) },
@@ -187,22 +189,22 @@ void tst_QXmppTrustMemoryStorage::testKeys()
     QMultiHash<QString, QByteArray> authenticatedKeys = { { QStringLiteral("bob@example.com"),
                                                             QByteArray::fromBase64(QByteArrayLiteral("YjVI04NcbTPvXLaA95RO84HPcSvyOgEZ2r5cTyUs0C8=")) } };
 
-    QHash<QByteArray, QXmppTrustStorage::TrustLevel> keysAlice = { { QByteArray::fromBase64(QByteArrayLiteral("WaAnpWyW1hnFooH3oJo9Ba5XYoksnLPeJRTAjxPbv38=")),
-                                                                     QXmppTrustStorage::AutomaticallyDistrusted },
-                                                                   { QByteArray::fromBase64(QByteArrayLiteral("/1eK3R2LtjPBT3el8f0q4DvzqUJSfFy5fkKkKPNFNYw=")),
-                                                                     QXmppTrustStorage::AutomaticallyDistrusted },
-                                                                   { QByteArray::fromBase64(QByteArrayLiteral("aFABnX7Q/rbTgjBySYzrT2FsYCVYb49mbca5yB734KQ=")),
-                                                                     QXmppTrustStorage::ManuallyDistrusted },
-                                                                   { QByteArray::fromBase64(QByteArrayLiteral("Ciemp4ZNzRJxnRD+k28vAie0kXJrwl4IrbfDy7n6OxE=")),
-                                                                     QXmppTrustStorage::AutomaticallyTrusted } };
-    QHash<QByteArray, QXmppTrustStorage::TrustLevel> keysBob = { { QByteArray::fromBase64(QByteArrayLiteral("rvSXBRd+EICMhQvVgcREQJxxP+T4EBmai4mYHBfJQGg=")),
-                                                                   QXmppTrustStorage::AutomaticallyTrusted },
-                                                                 { QByteArray::fromBase64(QByteArrayLiteral("tCP1CI3pqSTVGzFYFyPYUMfMZ9Ck/msmfD0wH/VtJBM=")),
-                                                                   QXmppTrustStorage::ManuallyTrusted },
-                                                                 { QByteArray::fromBase64(QByteArrayLiteral("2fhJtrgoMJxfLI3084/YkYh9paqiSiLFDVL2m0qAgX4=")),
-                                                                   QXmppTrustStorage::ManuallyTrusted },
-                                                                 { QByteArray::fromBase64(QByteArrayLiteral("YjVI04NcbTPvXLaA95RO84HPcSvyOgEZ2r5cTyUs0C8=")),
-                                                                   QXmppTrustStorage::Authenticated } };
+    QHash<QByteArray, TrustLevel> keysAlice = { { QByteArray::fromBase64(QByteArrayLiteral("WaAnpWyW1hnFooH3oJo9Ba5XYoksnLPeJRTAjxPbv38=")),
+                                                  TrustLevel::AutomaticallyDistrusted },
+                                                { QByteArray::fromBase64(QByteArrayLiteral("/1eK3R2LtjPBT3el8f0q4DvzqUJSfFy5fkKkKPNFNYw=")),
+                                                  TrustLevel::AutomaticallyDistrusted },
+                                                { QByteArray::fromBase64(QByteArrayLiteral("aFABnX7Q/rbTgjBySYzrT2FsYCVYb49mbca5yB734KQ=")),
+                                                  TrustLevel::ManuallyDistrusted },
+                                                { QByteArray::fromBase64(QByteArrayLiteral("Ciemp4ZNzRJxnRD+k28vAie0kXJrwl4IrbfDy7n6OxE=")),
+                                                  TrustLevel::AutomaticallyTrusted } };
+    QHash<QByteArray, TrustLevel> keysBob = { { QByteArray::fromBase64(QByteArrayLiteral("rvSXBRd+EICMhQvVgcREQJxxP+T4EBmai4mYHBfJQGg=")),
+                                                TrustLevel::AutomaticallyTrusted },
+                                              { QByteArray::fromBase64(QByteArrayLiteral("tCP1CI3pqSTVGzFYFyPYUMfMZ9Ck/msmfD0wH/VtJBM=")),
+                                                TrustLevel::ManuallyTrusted },
+                                              { QByteArray::fromBase64(QByteArrayLiteral("2fhJtrgoMJxfLI3084/YkYh9paqiSiLFDVL2m0qAgX4=")),
+                                                TrustLevel::ManuallyTrusted },
+                                              { QByteArray::fromBase64(QByteArrayLiteral("YjVI04NcbTPvXLaA95RO84HPcSvyOgEZ2r5cTyUs0C8=")),
+                                                TrustLevel::Authenticated } };
 
     // all OMEMO keys
     future = m_trustStorage.keys(ns_omemo);
@@ -211,33 +213,33 @@ void tst_QXmppTrustMemoryStorage::testKeys()
     QCOMPARE(
         result,
         QHash({ std::pair(
-                    QXmppTrustStorage::AutomaticallyDistrusted,
+                    TrustLevel::AutomaticallyDistrusted,
                     automaticallyDistrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::ManuallyDistrusted,
+                    TrustLevel::ManuallyDistrusted,
                     manuallyDistrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::AutomaticallyTrusted,
+                    TrustLevel::AutomaticallyTrusted,
                     automaticallyTrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::ManuallyTrusted,
+                    TrustLevel::ManuallyTrusted,
                     manuallyTrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::Authenticated,
+                    TrustLevel::Authenticated,
                     authenticatedKeys) }));
 
     // automatically trusted and authenticated OMEMO keys
     future = m_trustStorage.keys(ns_omemo,
-                                 QXmppTrustStorage::AutomaticallyTrusted | QXmppTrustStorage::Authenticated);
+                                 TrustLevel::AutomaticallyTrusted | TrustLevel::Authenticated);
     QVERIFY(future.isFinished());
     result = future.result();
     QCOMPARE(
         result,
         QHash({ std::pair(
-                    QXmppTrustStorage::AutomaticallyTrusted,
+                    TrustLevel::AutomaticallyTrusted,
                     automaticallyTrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::Authenticated,
+                    TrustLevel::Authenticated,
                     authenticatedKeys) }));
 
     // all OMEMO keys (via JIDs)
@@ -266,16 +268,16 @@ void tst_QXmppTrustMemoryStorage::testKeys()
             keysAlice) }));
 
     keysAlice = { { QByteArray::fromBase64(QByteArrayLiteral("Ciemp4ZNzRJxnRD+k28vAie0kXJrwl4IrbfDy7n6OxE=")),
-                    QXmppTrustStorage::AutomaticallyTrusted } };
+                    TrustLevel::AutomaticallyTrusted } };
     keysBob = { { QByteArray::fromBase64(QByteArrayLiteral("rvSXBRd+EICMhQvVgcREQJxxP+T4EBmai4mYHBfJQGg=")),
-                  QXmppTrustStorage::AutomaticallyTrusted },
+                  TrustLevel::AutomaticallyTrusted },
                 { QByteArray::fromBase64(QByteArrayLiteral("YjVI04NcbTPvXLaA95RO84HPcSvyOgEZ2r5cTyUs0C8=")),
-                  QXmppTrustStorage::Authenticated } };
+                  TrustLevel::Authenticated } };
 
     // automatically trusted and authenticated OMEMO keys (via JIDs)
     futureForJids = m_trustStorage.keys(ns_omemo,
                                         { QStringLiteral("alice@example.org"), QStringLiteral("bob@example.com") },
-                                        QXmppTrustStorage::AutomaticallyTrusted | QXmppTrustStorage::Authenticated);
+                                        TrustLevel::AutomaticallyTrusted | TrustLevel::Authenticated);
     QVERIFY(futureForJids.isFinished());
     resultForJids = futureForJids.result();
     QCOMPARE(
@@ -290,7 +292,7 @@ void tst_QXmppTrustMemoryStorage::testKeys()
     // Alice's automatically trusted and authenticated OMEMO keys
     futureForJids = m_trustStorage.keys(ns_omemo,
                                         { QStringLiteral("alice@example.org") },
-                                        QXmppTrustStorage::AutomaticallyTrusted | QXmppTrustStorage::Authenticated);
+                                        TrustLevel::AutomaticallyTrusted | TrustLevel::Authenticated);
     QVERIFY(futureForJids.isFinished());
     resultForJids = futureForJids.result();
     QCOMPARE(
@@ -302,7 +304,7 @@ void tst_QXmppTrustMemoryStorage::testKeys()
     // at least one automatically trusted or authenticated OMEMO key from Alice
     futureBool = m_trustStorage.hasKey(ns_omemo,
                                        QStringLiteral("alice@example.org"),
-                                       QXmppTrustStorage::AutomaticallyTrusted | QXmppTrustStorage::Authenticated);
+                                       TrustLevel::AutomaticallyTrusted | TrustLevel::Authenticated);
     QVERIFY(futureBool.isFinished());
     resultBool = futureBool.result();
     QVERIFY(resultBool);
@@ -317,17 +319,17 @@ void tst_QXmppTrustMemoryStorage::testKeys()
                                    QByteArray::fromBase64(QByteArrayLiteral("rvSXBRd+EICMhQvVgcREQJxxP+T4EBmai4mYHBfJQGg=")) } };
 
     keysAlice = { { QByteArray::fromBase64(QByteArrayLiteral("/1eK3R2LtjPBT3el8f0q4DvzqUJSfFy5fkKkKPNFNYw=")),
-                    QXmppTrustStorage::AutomaticallyDistrusted },
+                    TrustLevel::AutomaticallyDistrusted },
                   { QByteArray::fromBase64(QByteArrayLiteral("aFABnX7Q/rbTgjBySYzrT2FsYCVYb49mbca5yB734KQ=")),
-                    QXmppTrustStorage::ManuallyDistrusted } };
+                    TrustLevel::ManuallyDistrusted } };
     keysBob = { { QByteArray::fromBase64(QByteArrayLiteral("rvSXBRd+EICMhQvVgcREQJxxP+T4EBmai4mYHBfJQGg=")),
-                  QXmppTrustStorage::AutomaticallyTrusted },
+                  TrustLevel::AutomaticallyTrusted },
                 { QByteArray::fromBase64(QByteArrayLiteral("tCP1CI3pqSTVGzFYFyPYUMfMZ9Ck/msmfD0wH/VtJBM=")),
-                  QXmppTrustStorage::ManuallyTrusted },
+                  TrustLevel::ManuallyTrusted },
                 { QByteArray::fromBase64(QByteArrayLiteral("2fhJtrgoMJxfLI3084/YkYh9paqiSiLFDVL2m0qAgX4=")),
-                  QXmppTrustStorage::ManuallyTrusted },
+                  TrustLevel::ManuallyTrusted },
                 { QByteArray::fromBase64(QByteArrayLiteral("YjVI04NcbTPvXLaA95RO84HPcSvyOgEZ2r5cTyUs0C8=")),
-                  QXmppTrustStorage::Authenticated } };
+                  TrustLevel::Authenticated } };
 
     // OMEMO keys after removal
     future = m_trustStorage.keys(ns_omemo);
@@ -336,19 +338,19 @@ void tst_QXmppTrustMemoryStorage::testKeys()
     QCOMPARE(
         result,
         QHash({ std::pair(
-                    QXmppTrustStorage::AutomaticallyDistrusted,
+                    TrustLevel::AutomaticallyDistrusted,
                     automaticallyDistrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::ManuallyDistrusted,
+                    TrustLevel::ManuallyDistrusted,
                     manuallyDistrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::AutomaticallyTrusted,
+                    TrustLevel::AutomaticallyTrusted,
                     automaticallyTrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::ManuallyTrusted,
+                    TrustLevel::ManuallyTrusted,
                     manuallyTrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::Authenticated,
+                    TrustLevel::Authenticated,
                     authenticatedKeys) }));
 
     // OMEMO keys after removal (via JIDs)
@@ -377,16 +379,16 @@ void tst_QXmppTrustMemoryStorage::testKeys()
             keysAlice) }));
 
     keysAlice = { { QByteArray::fromBase64(QByteArrayLiteral("Ciemp4ZNzRJxnRD+k28vAie0kXJrwl4IrbfDy7n6OxE=")),
-                    QXmppTrustStorage::AutomaticallyTrusted } };
+                    TrustLevel::AutomaticallyTrusted } };
     keysBob = { { QByteArray::fromBase64(QByteArrayLiteral("rvSXBRd+EICMhQvVgcREQJxxP+T4EBmai4mYHBfJQGg=")),
-                  QXmppTrustStorage::AutomaticallyTrusted },
+                  TrustLevel::AutomaticallyTrusted },
                 { QByteArray::fromBase64(QByteArrayLiteral("YjVI04NcbTPvXLaA95RO84HPcSvyOgEZ2r5cTyUs0C8=")),
-                  QXmppTrustStorage::Authenticated } };
+                  TrustLevel::Authenticated } };
 
     // automatically trusted and authenticated OMEMO keys after removal (via JIDs)
     futureForJids = m_trustStorage.keys(ns_omemo,
                                         { QStringLiteral("alice@example.org"), QStringLiteral("bob@example.com") },
-                                        QXmppTrustStorage::AutomaticallyTrusted | QXmppTrustStorage::Authenticated);
+                                        TrustLevel::AutomaticallyTrusted | TrustLevel::Authenticated);
     QVERIFY(futureForJids.isFinished());
     resultForJids = futureForJids.result();
     QCOMPARE(
@@ -398,7 +400,7 @@ void tst_QXmppTrustMemoryStorage::testKeys()
     // Alice's automatically trusted and authenticated OMEMO keys after removal
     futureForJids = m_trustStorage.keys(ns_omemo,
                                         { QStringLiteral("alice@example.org") },
-                                        QXmppTrustStorage::AutomaticallyTrusted | QXmppTrustStorage::Authenticated);
+                                        TrustLevel::AutomaticallyTrusted | TrustLevel::Authenticated);
     QVERIFY(futureForJids.isFinished());
     resultForJids = futureForJids.result();
     QVERIFY(resultForJids.isEmpty());
@@ -412,13 +414,13 @@ void tst_QXmppTrustMemoryStorage::testKeys()
     QCOMPARE(
         result,
         QHash({ std::pair(
-                    QXmppTrustStorage::AutomaticallyTrusted,
+                    TrustLevel::AutomaticallyTrusted,
                     automaticallyTrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::ManuallyTrusted,
+                    TrustLevel::ManuallyTrusted,
                     manuallyTrustedKeys),
                 std::pair(
-                    QXmppTrustStorage::Authenticated,
+                    TrustLevel::Authenticated,
                     authenticatedKeys) }));
 
     m_trustStorage.removeKeys(ns_omemo);
@@ -435,9 +437,9 @@ void tst_QXmppTrustMemoryStorage::testKeys()
                             QByteArray::fromBase64(QByteArrayLiteral("IhpPjiKLchgrAG5cpSfTvdzPjZ5v6vTOluHEUehkgCA=")) } };
 
     keysAlice = { { QByteArray::fromBase64(QByteArrayLiteral("aFABnX7Q/rbTgjBySYzrT2FsYCVYb49mbca5yB734KQ=")),
-                    QXmppTrustStorage::Authenticated },
+                    TrustLevel::Authenticated },
                   { QByteArray::fromBase64(QByteArrayLiteral("IhpPjiKLchgrAG5cpSfTvdzPjZ5v6vTOluHEUehkgCA=")),
-                    QXmppTrustStorage::Authenticated } };
+                    TrustLevel::Authenticated } };
 
     // remaining OX keys
     future = m_trustStorage.keys(ns_ox);
@@ -446,7 +448,7 @@ void tst_QXmppTrustMemoryStorage::testKeys()
     QCOMPARE(
         result,
         QHash({ std::pair(
-            QXmppTrustStorage::Authenticated,
+            TrustLevel::Authenticated,
             authenticatedKeys) }));
 
     // remaining OX keys (via JIDs)
@@ -489,7 +491,7 @@ void tst_QXmppTrustMemoryStorage::testKeys()
     // no automatically trusted or authenticated OX key from Alice
     futureBool = m_trustStorage.hasKey(ns_ox,
                                        QStringLiteral("alice@example.org"),
-                                       QXmppTrustStorage::AutomaticallyTrusted | QXmppTrustStorage::Authenticated);
+                                       TrustLevel::AutomaticallyTrusted | TrustLevel::Authenticated);
     QVERIFY(futureBool.isFinished());
     resultBool = futureBool.result();
     QVERIFY(!resultBool);
@@ -501,26 +503,26 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         ns_ox,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("AZ/cF4OrUOILKO1gQBf62pQevOhBJ2NyHnXLwM4FDZU=")) },
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("AZ/cF4OrUOILKO1gQBf62pQevOhBJ2NyHnXLwM4FDZU=")),
           QByteArray::fromBase64(QByteArrayLiteral("JU4pT7Ivpigtl+7QE87Bkq4r/C/mhI1FCjY5Wmjbtwg=")) },
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("aFABnX7Q/rbTgjBySYzrT2FsYCVYb49mbca5yB734KQ=")) },
-        QXmppTrustStorage::ManuallyTrusted);
+        TrustLevel::ManuallyTrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("9E51lG3vVmUn8CM7/AIcmIlLP2HPl6Ao0/VSf4VT/oA=")) },
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     auto future = m_trustStorage.trustLevel(
         ns_omemo,
@@ -528,7 +530,7 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         QByteArray::fromBase64(QByteArrayLiteral("AZ/cF4OrUOILKO1gQBf62pQevOhBJ2NyHnXLwM4FDZU=")));
     QVERIFY(future.isFinished());
     auto result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::AutomaticallyTrusted);
+    QCOMPARE(result, TrustLevel::AutomaticallyTrusted);
 
     m_trustStorage.setTrustLevel(
         ns_omemo,
@@ -536,7 +538,7 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
             QByteArray::fromBase64(QByteArrayLiteral("AZ/cF4OrUOILKO1gQBf62pQevOhBJ2NyHnXLwM4FDZU=")) },
           { QStringLiteral("bob@example.com"),
             QByteArray::fromBase64(QByteArrayLiteral("9E51lG3vVmUn8CM7/AIcmIlLP2HPl6Ao0/VSf4VT/oA=")) } },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     future = m_trustStorage.trustLevel(
         ns_omemo,
@@ -544,7 +546,7 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         QByteArray::fromBase64(QByteArrayLiteral("AZ/cF4OrUOILKO1gQBf62pQevOhBJ2NyHnXLwM4FDZU=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::Authenticated);
+    QCOMPARE(result, TrustLevel::Authenticated);
 
     future = m_trustStorage.trustLevel(
         ns_omemo,
@@ -552,7 +554,7 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         QByteArray::fromBase64(QByteArrayLiteral("9E51lG3vVmUn8CM7/AIcmIlLP2HPl6Ao0/VSf4VT/oA=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::Authenticated);
+    QCOMPARE(result, TrustLevel::Authenticated);
 
     // Set the trust level of a key that is not stored yet.
     // It is added to the storage automatically.
@@ -560,7 +562,7 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         ns_omemo,
         { { QStringLiteral("alice@example.org"),
             QByteArray::fromBase64(QByteArrayLiteral("9w6oPjKyGSALd9gHq7sNOdOAkD5bHUVOKACNs89FjkA=")) } },
-        QXmppTrustStorage::ManuallyTrusted);
+        TrustLevel::ManuallyTrusted);
 
     future = m_trustStorage.trustLevel(
         ns_omemo,
@@ -568,7 +570,7 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         QByteArray::fromBase64(QByteArrayLiteral("9w6oPjKyGSALd9gHq7sNOdOAkD5bHUVOKACNs89FjkA=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::ManuallyTrusted);
+    QCOMPARE(result, TrustLevel::ManuallyTrusted);
 
     // Try to retrieve the trust level of a key that is not stored yet.
     // The default value is returned.
@@ -578,7 +580,7 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         QByteArray::fromBase64(QByteArrayLiteral("WXL4EDfzUGbVPQWjT9pmBeiCpCBzYZv3lUAaj+UbPyE=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::Undecided);
+    QCOMPARE(result, TrustLevel::Undecided);
 
     // Set the trust levels of all authenticated keys belonging to Alice and
     // Bob.
@@ -586,8 +588,8 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         ns_omemo,
         { QStringLiteral("alice@example.org"),
           QStringLiteral("bob@example.com") },
-        QXmppTrustStorage::Authenticated,
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::Authenticated,
+        TrustLevel::ManuallyDistrusted);
 
     future = m_trustStorage.trustLevel(
         ns_omemo,
@@ -595,7 +597,7 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         QByteArray::fromBase64(QByteArrayLiteral("AZ/cF4OrUOILKO1gQBf62pQevOhBJ2NyHnXLwM4FDZU=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::ManuallyDistrusted);
+    QCOMPARE(result, TrustLevel::ManuallyDistrusted);
 
     future = m_trustStorage.trustLevel(
         ns_omemo,
@@ -603,7 +605,7 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         QByteArray::fromBase64(QByteArrayLiteral("9E51lG3vVmUn8CM7/AIcmIlLP2HPl6Ao0/VSf4VT/oA=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::ManuallyDistrusted);
+    QCOMPARE(result, TrustLevel::ManuallyDistrusted);
 
     // Verify that the default trust level is returned for an unknown key.
     future = m_trustStorage.trustLevel(
@@ -612,7 +614,7 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
         QByteArray::fromBase64(QByteArrayLiteral("wE06Gwf8f4DvDLFDoaCsGs8ibcUjf84WIOA2FAjPI3o=")));
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::Undecided);
+    QCOMPARE(result, TrustLevel::Undecided);
 
     m_trustStorage.removeKeys(ns_ox);
     m_trustStorage.removeKeys(ns_omemo);
@@ -620,8 +622,8 @@ void tst_QXmppTrustMemoryStorage::testTrustLevels()
 
 void tst_QXmppTrustMemoryStorage::testResetAll()
 {
-    m_trustStorage.setSecurityPolicy(ns_ox, QXmppTrustStorage::Toakafa);
-    m_trustStorage.setSecurityPolicy(ns_omemo, QXmppTrustStorage::Toakafa);
+    m_trustStorage.setSecurityPolicy(ns_ox, Toakafa);
+    m_trustStorage.setSecurityPolicy(ns_omemo, Toakafa);
 
     m_trustStorage.setOwnKey(ns_ox, QByteArray::fromBase64(QByteArrayLiteral("aFABnX7Q/rbTgjBySYzrT2FsYCVYb49mbca5yB734KQ=")));
     m_trustStorage.setOwnKey(ns_omemo, QByteArray::fromBase64(QByteArrayLiteral("IhpPjiKLchgrAG5cpSfTvdzPjZ5v6vTOluHEUehkgCA=")));
@@ -636,51 +638,51 @@ void tst_QXmppTrustMemoryStorage::testResetAll()
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("aFABnX7Q/rbTgjBySYzrT2FsYCVYb49mbca5yB734KQ=")) },
-        QXmppTrustStorage::ManuallyDistrusted);
+        TrustLevel::ManuallyDistrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("Ciemp4ZNzRJxnRD+k28vAie0kXJrwl4IrbfDy7n6OxE=")) },
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("rvSXBRd+EICMhQvVgcREQJxxP+T4EBmai4mYHBfJQGg=")) },
-        QXmppTrustStorage::AutomaticallyTrusted);
+        TrustLevel::AutomaticallyTrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("tCP1CI3pqSTVGzFYFyPYUMfMZ9Ck/msmfD0wH/VtJBM=")),
           QByteArray::fromBase64(QByteArrayLiteral("2fhJtrgoMJxfLI3084/YkYh9paqiSiLFDVL2m0qAgX4=")) },
-        QXmppTrustStorage::ManuallyTrusted);
+        TrustLevel::ManuallyTrusted);
 
     m_trustStorage.addKeys(
         ns_omemo,
         QStringLiteral("bob@example.com"),
         { QByteArray::fromBase64(QByteArrayLiteral("YjVI04NcbTPvXLaA95RO84HPcSvyOgEZ2r5cTyUs0C8=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     m_trustStorage.addKeys(
         ns_ox,
         QStringLiteral("alice@example.org"),
         { QByteArray::fromBase64(QByteArrayLiteral("aFABnX7Q/rbTgjBySYzrT2FsYCVYb49mbca5yB734KQ=")),
           QByteArray::fromBase64(QByteArrayLiteral("IhpPjiKLchgrAG5cpSfTvdzPjZ5v6vTOluHEUehkgCA=")) },
-        QXmppTrustStorage::Authenticated);
+        TrustLevel::Authenticated);
 
     m_trustStorage.resetAll(ns_omemo);
 
     auto future = m_trustStorage.securityPolicy(ns_omemo);
     QVERIFY(future.isFinished());
     auto result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::NoSecurityPolicy);
+    QCOMPARE(result, NoSecurityPolicy);
 
     future = m_trustStorage.securityPolicy(ns_ox);
     QVERIFY(future.isFinished());
     result = future.result();
-    QCOMPARE(result, QXmppTrustStorage::Toakafa);
+    QCOMPARE(result, Toakafa);
 
     auto futureKey = m_trustStorage.ownKey(ns_omemo);
     QVERIFY(futureKey.isFinished());
@@ -708,7 +710,7 @@ void tst_QXmppTrustMemoryStorage::testResetAll()
     QCOMPARE(
         resultKeys,
         QHash({ std::pair(
-            QXmppTrustStorage::Authenticated,
+            TrustLevel::Authenticated,
             authenticatedKeys) }));
 }