5 files changed, 114 insertions, 115 deletions

diff --git a/examples/imapresource/CMakeLists.txt b/examples/imapresource/CMakeLists.txt
index d5320a6..15a720d 100644
--- a/examples/imapresource/CMakeLists.txt
+++ b/examples/imapresource/CMakeLists.txt
@@ -3,15 +3,14 @@ project(sink_resource_imap)
 add_definitions(-DQT_PLUGIN)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
-find_package(KF5 COMPONENTS REQUIRED Mime IMAP KIO)
-find_package(KF5CoreAddons REQUIRED)
+find_package(KF5 COMPONENTS REQUIRED Mime)
+find_package(KIMAP2 0.0.1 REQUIRED)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
 add_library(${PROJECT_NAME} SHARED facade.cpp imapresource.cpp domainadaptor.cpp imapserverproxy.cpp)
 qt5_use_modules(${PROJECT_NAME} Core Network)
-#We need CoreAddons for KJob and KIOCore for KTcpSocket. Both used in KIMAP
-target_link_libraries(${PROJECT_NAME} sink KF5::Mime KF5::IMAP KF5::CoreAddons KF5::KIOCore)
+target_link_libraries(${PROJECT_NAME} sink KF5::Mime KIMAP2)
 
 install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${SINK_RESOURCE_PLUGINS_PATH})
 
diff --git a/examples/imapresource/imapresource.cpp b/examples/imapresource/imapresource.cpp
index f78376a..da87bdb 100644
--- a/examples/imapresource/imapresource.cpp
+++ b/examples/imapresource/imapresource.cpp
@@ -344,7 +344,7 @@ public:
             const QString mailbox = syncStore().resolveLocalId(ENTITY_TYPE_FOLDER, folderId);
             const auto uid = uidFromMailRid(oldRemoteId);
             SinkTrace() << "Removing a mail: " << oldRemoteId << "in the mailbox: " << mailbox;
-            KIMAP::ImapSet set;
+            KIMAP2::ImapSet set;
             set.add(uid);
             return login.then(imap->remove(mailbox, set))
                 .syncThen<QByteArray>([imap, oldRemoteId] {
@@ -373,7 +373,7 @@ public:
                 const QString oldMailbox = syncStore().resolveLocalId(ENTITY_TYPE_FOLDER, folderId);
                 QByteArray content = KMime::LFtoCRLF(mail.getMimeMessage());
                 QDateTime internalDate = mail.getDate();
-                KIMAP::ImapSet set;
+                KIMAP2::ImapSet set;
                 set.add(uid);
                 return login.then(imap->append(mailbox, content, flags, internalDate))
                     .addToContext(imap)
@@ -384,7 +384,7 @@ public:
                     });
             } else {
                 SinkTrace() << "Updating flags only.";
-                KIMAP::ImapSet set;
+                KIMAP2::ImapSet set;
                 set.add(uid);
                 return login.then(imap->select(mailbox))
                     .addToContext(imap)
@@ -548,13 +548,13 @@ KAsync::Job<void> ImapResource::inspect(int inspectionType, const QByteArray &in
         const auto uid = uidFromMailRid(mailRemoteId);
         SinkTrace() << "Mail remote id: " << folderRemoteId << mailRemoteId << mail.identifier() << folder.identifier();
 
-        KIMAP::ImapSet set;
+        KIMAP2::ImapSet set;
         set.add(uid);
         if (set.isEmpty()) {
             return KAsync::error<void>(1, "Couldn't determine uid of mail.");
         }
-        KIMAP::FetchJob::FetchScope scope;
-        scope.mode = KIMAP::FetchJob::FetchScope::Full;
+        KIMAP2::FetchJob::FetchScope scope;
+        scope.mode = KIMAP2::FetchJob::FetchScope::Full;
         auto imap = QSharedPointer<ImapServerProxy>::create(mServer, mPort);
         auto messageByUid = QSharedPointer<QHash<qint64, Imap::Message>>::create();
         SinkTrace() << "Connecting to:" << mServer << mPort;
@@ -618,9 +618,9 @@ KAsync::Job<void> ImapResource::inspect(int inspectionType, const QByteArray &in
                 SinkWarning() << "Error in index: " <<  error.message << property;
             });
 
-            auto set = KIMAP::ImapSet::fromImapSequenceSet("1:*");
-            KIMAP::FetchJob::FetchScope scope;
-            scope.mode = KIMAP::FetchJob::FetchScope::Headers;
+            auto set = KIMAP2::ImapSet::fromImapSequenceSet("1:*");
+            KIMAP2::FetchJob::FetchScope scope;
+            scope.mode = KIMAP2::FetchJob::FetchScope::Headers;
             auto imap = QSharedPointer<ImapServerProxy>::create(mServer, mPort);
             auto messageByUid = QSharedPointer<QHash<qint64, Imap::Message>>::create();
             return imap->login(mUser, mPassword)
diff --git a/examples/imapresource/imapserverproxy.cpp b/examples/imapresource/imapserverproxy.cpp
index 921eeff..25cbc57 100644
--- a/examples/imapresource/imapserverproxy.cpp
+++ b/examples/imapresource/imapserverproxy.cpp
@@ -22,18 +22,18 @@
 #include <QFile>
 #include <QTcpSocket>
 #include <QTimer>
-#include <KIMAP/KIMAP/LoginJob>
-#include <kimap/namespacejob.h>
-#include <KIMAP/KIMAP/SelectJob>
-#include <KIMAP/KIMAP/AppendJob>
-#include <KIMAP/KIMAP/CreateJob>
-#include <KIMAP/KIMAP/CopyJob>
-#include <KIMAP/KIMAP/RenameJob>
-#include <KIMAP/KIMAP/DeleteJob>
-#include <KIMAP/KIMAP/StoreJob>
-#include <KIMAP/KIMAP/ExpungeJob>
-#include <KIMAP/KIMAP/CapabilitiesJob>
-#include <KIMAP/KIMAP/SearchJob>
+#include <KIMAP2/LoginJob>
+#include <KIMAP2/NamespaceJob>
+#include <KIMAP2/SelectJob>
+#include <KIMAP2/AppendJob>
+#include <KIMAP2/CreateJob>
+#include <KIMAP2/CopyJob>
+#include <KIMAP2/RenameJob>
+#include <KIMAP2/DeleteJob>
+#include <KIMAP2/StoreJob>
+#include <KIMAP2/ExpungeJob>
+#include <KIMAP2/CapabilitiesJob>
+#include <KIMAP2/SearchJob>
 
 #include <KCoreAddons/KJob>
 
@@ -90,9 +90,9 @@ static KAsync::Job<void> runJob(KJob *job)
     });
 }
 
-ImapServerProxy::ImapServerProxy(const QString &serverUrl, int port) : mSession(new KIMAP::Session(serverUrl, qint16(port)))
+ImapServerProxy::ImapServerProxy(const QString &serverUrl, int port) : mSession(new KIMAP2::Session(serverUrl, qint16(port)))
 {
-    QObject::connect(mSession, &KIMAP::Session::sslErrors, [this](const QList<QSslError> &errors) {
+    QObject::connect(mSession, &KIMAP2::Session::sslErrors, [this](const QList<QSslError> &errors) {
         SinkLog() << "Got ssl error: " << errors;
         mSession->ignoreErrors(errors);
     });
@@ -106,21 +106,21 @@ ImapServerProxy::ImapServerProxy(const QString &serverUrl, int port) : mSession(
 
 KAsync::Job<void> ImapServerProxy::login(const QString &username, const QString &password)
 {
-    auto loginJob = new KIMAP::LoginJob(mSession);
+    auto loginJob = new KIMAP2::LoginJob(mSession);
     loginJob->setUserName(username);
     loginJob->setPassword(password);
-    loginJob->setAuthenticationMode(KIMAP::LoginJob::Plain);
+    loginJob->setAuthenticationMode(KIMAP2::LoginJob::Plain);
     if (mSession->port() == 143) {
         loginJob->setEncryptionMode(QSsl::TlsV1_0OrLater, true);
     } else {
         loginJob->setEncryptionMode(QSsl::AnyProtocol, false);
     }
 
-    auto capabilitiesJob = new KIMAP::CapabilitiesJob(mSession);
-    QObject::connect(capabilitiesJob, &KIMAP::CapabilitiesJob::capabilitiesReceived, &mGuard, [this](const QStringList &capabilities) {
+    auto capabilitiesJob = new KIMAP2::CapabilitiesJob(mSession);
+    QObject::connect(capabilitiesJob, &KIMAP2::CapabilitiesJob::capabilitiesReceived, &mGuard, [this](const QStringList &capabilities) {
         mCapabilities = capabilities;
     });
-    auto namespaceJob = new KIMAP::NamespaceJob(mSession);
+    auto namespaceJob = new KIMAP2::NamespaceJob(mSession);
 
     return runJob(loginJob).then(runJob(capabilitiesJob)).syncThen<void>([this](){
         SinkTrace() << "Supported capabilities: " << mCapabilities;
@@ -152,7 +152,7 @@ KAsync::Job<void> ImapServerProxy::login(const QString &username, const QString
 
 KAsync::Job<SelectResult> ImapServerProxy::select(const QString &mailbox)
 {
-    auto select = new KIMAP::SelectJob(mSession);
+    auto select = new KIMAP2::SelectJob(mSession);
     select->setMailBox(mailbox);
     select->setCondstoreEnabled(mCapabilities.contains("CONDSTORE"));
     return runJob<SelectResult>(select, [select](KJob* job) -> SelectResult {
@@ -162,46 +162,46 @@ KAsync::Job<SelectResult> ImapServerProxy::select(const QString &mailbox)
 
 KAsync::Job<qint64> ImapServerProxy::append(const QString &mailbox, const QByteArray &content, const QList<QByteArray> &flags, const QDateTime &internalDate)
 {
-    auto append = new KIMAP::AppendJob(mSession);
+    auto append = new KIMAP2::AppendJob(mSession);
     append->setMailBox(mailbox);
     append->setContent(content);
     append->setFlags(flags);
     append->setInternalDate(internalDate);
     return runJob<qint64>(append, [](KJob *job) -> qint64{
-        return static_cast<KIMAP::AppendJob*>(job)->uid();
+        return static_cast<KIMAP2::AppendJob*>(job)->uid();
     });
 }
 
-KAsync::Job<void> ImapServerProxy::store(const KIMAP::ImapSet &set, const QList<QByteArray> &flags)
+KAsync::Job<void> ImapServerProxy::store(const KIMAP2::ImapSet &set, const QList<QByteArray> &flags)
 {
     return storeFlags(set, flags);
 }
 
-KAsync::Job<void> ImapServerProxy::storeFlags(const KIMAP::ImapSet &set, const QList<QByteArray> &flags)
+KAsync::Job<void> ImapServerProxy::storeFlags(const KIMAP2::ImapSet &set, const QList<QByteArray> &flags)
 {
-    auto store = new KIMAP::StoreJob(mSession);
+    auto store = new KIMAP2::StoreJob(mSession);
     store->setUidBased(true);
-    store->setMode(KIMAP::StoreJob::SetFlags);
+    store->setMode(KIMAP2::StoreJob::SetFlags);
     store->setSequenceSet(set);
     store->setFlags(flags);
     return runJob(store);
 }
 
-KAsync::Job<void> ImapServerProxy::addFlags(const KIMAP::ImapSet &set, const QList<QByteArray> &flags)
+KAsync::Job<void> ImapServerProxy::addFlags(const KIMAP2::ImapSet &set, const QList<QByteArray> &flags)
 {
-    auto store = new KIMAP::StoreJob(mSession);
+    auto store = new KIMAP2::StoreJob(mSession);
     store->setUidBased(true);
-    store->setMode(KIMAP::StoreJob::AppendFlags);
+    store->setMode(KIMAP2::StoreJob::AppendFlags);
     store->setSequenceSet(set);
     store->setFlags(flags);
     return runJob(store);
 }
 
-KAsync::Job<void> ImapServerProxy::removeFlags(const KIMAP::ImapSet &set, const QList<QByteArray> &flags)
+KAsync::Job<void> ImapServerProxy::removeFlags(const KIMAP2::ImapSet &set, const QList<QByteArray> &flags)
 {
-    auto store = new KIMAP::StoreJob(mSession);
+    auto store = new KIMAP2::StoreJob(mSession);
     store->setUidBased(true);
-    store->setMode(KIMAP::StoreJob::RemoveFlags);
+    store->setMode(KIMAP2::StoreJob::RemoveFlags);
     store->setSequenceSet(set);
     store->setFlags(flags);
     return runJob(store);
@@ -209,14 +209,14 @@ KAsync::Job<void> ImapServerProxy::removeFlags(const KIMAP::ImapSet &set, const
 
 KAsync::Job<void> ImapServerProxy::create(const QString &mailbox)
 {
-    auto create = new KIMAP::CreateJob(mSession);
+    auto create = new KIMAP2::CreateJob(mSession);
     create->setMailBox(mailbox);
     return runJob(create);
 }
 
 KAsync::Job<void> ImapServerProxy::rename(const QString &mailbox, const QString &newMailbox)
 {
-    auto rename = new KIMAP::RenameJob(mSession);
+    auto rename = new KIMAP2::RenameJob(mSession);
     rename->setSourceMailBox(mailbox);
     rename->setDestinationMailBox(newMailbox);
     return runJob(rename);
@@ -224,68 +224,68 @@ KAsync::Job<void> ImapServerProxy::rename(const QString &mailbox, const QString
 
 KAsync::Job<void> ImapServerProxy::remove(const QString &mailbox)
 {
-    auto job = new KIMAP::DeleteJob(mSession);
+    auto job = new KIMAP2::DeleteJob(mSession);
     job->setMailBox(mailbox);
     return runJob(job);
 }
 
 KAsync::Job<void> ImapServerProxy::expunge()
 {
-    auto job = new KIMAP::ExpungeJob(mSession);
+    auto job = new KIMAP2::ExpungeJob(mSession);
     return runJob(job);
 }
 
-KAsync::Job<void> ImapServerProxy::expunge(const KIMAP::ImapSet &set)
+KAsync::Job<void> ImapServerProxy::expunge(const KIMAP2::ImapSet &set)
 {
     //FIXME implement UID EXPUNGE
-    auto job = new KIMAP::ExpungeJob(mSession);
+    auto job = new KIMAP2::ExpungeJob(mSession);
     return runJob(job);
 }
 
-KAsync::Job<void> ImapServerProxy::copy(const KIMAP::ImapSet &set, const QString &newMailbox)
+KAsync::Job<void> ImapServerProxy::copy(const KIMAP2::ImapSet &set, const QString &newMailbox)
 {
-    auto copy = new KIMAP::CopyJob(mSession);
+    auto copy = new KIMAP2::CopyJob(mSession);
     copy->setSequenceSet(set);
     copy->setUidBased(true);
     copy->setMailBox(newMailbox);
     return runJob(copy);
 }
 
-KAsync::Job<void> ImapServerProxy::fetch(const KIMAP::ImapSet &set, KIMAP::FetchJob::FetchScope scope, FetchCallback callback)
+KAsync::Job<void> ImapServerProxy::fetch(const KIMAP2::ImapSet &set, KIMAP2::FetchJob::FetchScope scope, FetchCallback callback)
 {
-    auto fetch = new KIMAP::FetchJob(mSession);
+    auto fetch = new KIMAP2::FetchJob(mSession);
     fetch->setSequenceSet(set);
     fetch->setUidBased(true);
     fetch->setScope(scope);
-    QObject::connect(fetch, static_cast<void(KIMAP::FetchJob::*)(const QString &,
+    QObject::connect(fetch, static_cast<void(KIMAP2::FetchJob::*)(const QString &,
                     const QMap<qint64,qint64> &,
                     const QMap<qint64,qint64> &,
-                    const QMap<qint64,KIMAP::MessageAttribute> &,
-                    const QMap<qint64,KIMAP::MessageFlags> &,
-                    const QMap<qint64,KIMAP::MessagePtr> &)>(&KIMAP::FetchJob::headersReceived),
+                    const QMap<qint64,KIMAP2::MessageAttribute> &,
+                    const QMap<qint64,KIMAP2::MessageFlags> &,
+                    const QMap<qint64,KIMAP2::MessagePtr> &)>(&KIMAP2::FetchJob::headersReceived),
             callback);
     return runJob(fetch);
 }
 
-KAsync::Job<QVector<qint64>> ImapServerProxy::search(const KIMAP::ImapSet &set)
+KAsync::Job<QVector<qint64>> ImapServerProxy::search(const KIMAP2::ImapSet &set)
 {
-    auto search = new KIMAP::SearchJob(mSession);
-    search->setTerm(KIMAP::Term(KIMAP::Term::Uid, set));
+    auto search = new KIMAP2::SearchJob(mSession);
+    search->setTerm(KIMAP2::Term(KIMAP2::Term::Uid, set));
     search->setUidBased(true);
     return runJob<QVector<qint64>>(search, [](KJob *job) -> QVector<qint64> {
-        return static_cast<KIMAP::SearchJob*>(job)->results();
+        return static_cast<KIMAP2::SearchJob*>(job)->results();
     });
 }
 
-KAsync::Job<void> ImapServerProxy::fetch(const KIMAP::ImapSet &set, KIMAP::FetchJob::FetchScope scope, const std::function<void(const QVector<Message> &)> &callback)
+KAsync::Job<void> ImapServerProxy::fetch(const KIMAP2::ImapSet &set, KIMAP2::FetchJob::FetchScope scope, const std::function<void(const QVector<Message> &)> &callback)
 {
     return fetch(set, scope,
                     [callback](const QString &mailbox,
                             const QMap<qint64,qint64> &uids,
                             const QMap<qint64,qint64> &sizes,
-                            const QMap<qint64,KIMAP::MessageAttribute> &attrs,
-                            const QMap<qint64,KIMAP::MessageFlags> &flags,
-                            const QMap<qint64,KIMAP::MessagePtr> &messages) {
+                            const QMap<qint64,KIMAP2::MessageAttribute> &attrs,
+                            const QMap<qint64,KIMAP2::MessageFlags> &flags,
+                            const QMap<qint64,KIMAP2::MessagePtr> &messages) {
                         QVector<Message> list;
                         for (const auto &id : uids.keys()) {
                             list << Message{uids.value(id), sizes.value(id), attrs.value(id), flags.value(id), messages.value(id)};
@@ -302,17 +302,17 @@ QStringList ImapServerProxy::getCapabilities() const
 KAsync::Job<QList<qint64>> ImapServerProxy::fetchHeaders(const QString &mailbox, const qint64 minUid)
 {
     auto list = QSharedPointer<QList<qint64>>::create();
-    KIMAP::FetchJob::FetchScope scope;
-    scope.mode = KIMAP::FetchJob::FetchScope::Flags;
+    KIMAP2::FetchJob::FetchScope scope;
+    scope.mode = KIMAP2::FetchJob::FetchScope::Flags;
 
     //Fetch headers of all messages
-    return fetch(KIMAP::ImapSet(minUid, 0), scope,
+    return fetch(KIMAP2::ImapSet(minUid, 0), scope,
             [list](const QString &mailbox,
                     const QMap<qint64,qint64> &uids,
                     const QMap<qint64,qint64> &sizes,
-                    const QMap<qint64,KIMAP::MessageAttribute> &attrs,
-                    const QMap<qint64,KIMAP::MessageFlags> &flags,
-                    const QMap<qint64,KIMAP::MessagePtr> &messages) {
+                    const QMap<qint64,KIMAP2::MessageAttribute> &attrs,
+                    const QMap<qint64,KIMAP2::MessageFlags> &flags,
+                    const QMap<qint64,KIMAP2::MessagePtr> &messages) {
                 SinkTrace() << "Received " << uids.size() << " headers from " << mailbox;
                 SinkTrace() << uids.size() << sizes.size() << attrs.size() << flags.size() << messages.size();
 
@@ -331,32 +331,32 @@ KAsync::Job<QList<qint64>> ImapServerProxy::fetchHeaders(const QString &mailbox,
 
 KAsync::Job<QVector<qint64>> ImapServerProxy::fetchUids(const QString &mailbox)
 {
-    return select(mailbox).then<QVector<qint64>>(search(KIMAP::ImapSet(1, 0)));
+    return select(mailbox).then<QVector<qint64>>(search(KIMAP2::ImapSet(1, 0)));
 }
 
-KAsync::Job<void> ImapServerProxy::list(KIMAP::ListJob::Option option, const std::function<void(const QList<KIMAP::MailBoxDescriptor> &mailboxes,const QList<QList<QByteArray> > &flags)> &callback)
+KAsync::Job<void> ImapServerProxy::list(KIMAP2::ListJob::Option option, const std::function<void(const QList<KIMAP2::MailBoxDescriptor> &mailboxes,const QList<QList<QByteArray> > &flags)> &callback)
 {
-    auto listJob = new KIMAP::ListJob(mSession);
+    auto listJob = new KIMAP2::ListJob(mSession);
     listJob->setOption(option);
     // listJob->setQueriedNamespaces(serverNamespaces());
-    QObject::connect(listJob, &KIMAP::ListJob::mailBoxesReceived,
+    QObject::connect(listJob, &KIMAP2::ListJob::mailBoxesReceived,
             listJob, callback);
     return runJob(listJob);
 }
 
-KAsync::Job<void> ImapServerProxy::remove(const QString &mailbox, const KIMAP::ImapSet &set)
+KAsync::Job<void> ImapServerProxy::remove(const QString &mailbox, const KIMAP2::ImapSet &set)
 {
     return select(mailbox).then<void>(store(set, QByteArrayList() << Flags::Deleted)).then<void>(expunge(set));
 }
 
 KAsync::Job<void> ImapServerProxy::remove(const QString &mailbox, const QByteArray &imapSet)
 {
-    const auto set = KIMAP::ImapSet::fromImapSequenceSet(imapSet);
+    const auto set = KIMAP2::ImapSet::fromImapSequenceSet(imapSet);
     return remove(mailbox, set);
 }
 
 
-KAsync::Job<void> ImapServerProxy::move(const QString &mailbox, const KIMAP::ImapSet &set, const QString &newMailbox)
+KAsync::Job<void> ImapServerProxy::move(const QString &mailbox, const KIMAP2::ImapSet &set, const QString &newMailbox)
 {
     return select(mailbox).then<void>(copy(set, newMailbox)).then<void>(store(set, QByteArrayList() << Flags::Deleted)).then<void>(expunge(set));
 }
@@ -397,7 +397,7 @@ KAsync::Job<QString> ImapServerProxy::renameSubfolder(const QString &oldMailbox,
 KAsync::Job<void> ImapServerProxy::fetchFolders(std::function<void(const QVector<Folder> &)> callback)
 {
     SinkTrace() << "Fetching folders";
-    return list(KIMAP::ListJob::IncludeUnsubscribed, [callback](const QList<KIMAP::MailBoxDescriptor> &mailboxes, const QList<QList<QByteArray> > &flags){
+    return list(KIMAP2::ListJob::IncludeUnsubscribed, [callback](const QList<KIMAP2::MailBoxDescriptor> &mailboxes, const QList<QList<QByteArray> > &flags){
         QVector<Folder> list;
         for (int i = 0; i < mailboxes.size(); i++) {
             const auto mailbox = mailboxes[i];
@@ -443,11 +443,11 @@ KAsync::Job<void> ImapServerProxy::fetchMessages(const Folder &folder, qint64 ui
                 callback(QVector<Message>());
                 return KAsync::null<void>();
             }
-            KIMAP::FetchJob::FetchScope scope;
+            KIMAP2::FetchJob::FetchScope scope;
             scope.parts.clear();
-            scope.mode = KIMAP::FetchJob::FetchScope::Full;
+            scope.mode = KIMAP2::FetchJob::FetchScope::Full;
 
-            KIMAP::ImapSet set;
+            KIMAP2::ImapSet set;
             set.add(uidsToFetch.toVector());
             auto count = QSharedPointer<int>::create();
             return fetch(set, scope, [=](const QVector<Message> &messages) {
diff --git a/examples/imapresource/imapserverproxy.h b/examples/imapresource/imapserverproxy.h
index 70dfa58..9adce3d 100644
--- a/examples/imapresource/imapserverproxy.h
+++ b/examples/imapresource/imapserverproxy.h
@@ -22,9 +22,9 @@
 #include <Async/Async>
 
 #include <KMime/KMime/KMimeMessage>
-#include <KIMAP/KIMAP/ListJob>
-#include <KIMAP/KIMAP/Session>
-#include <KIMAP/KIMAP/FetchJob>
+#include <KIMAP2/ListJob>
+#include <KIMAP2/Session>
+#include <KIMAP2/FetchJob>
 
 namespace Imap {
 
@@ -82,7 +82,7 @@ struct SelectResult {
 };
 
 class ImapServerProxy {
-    KIMAP::Session *mSession;
+    KIMAP2::Session *mSession;
     QStringList mCapabilities;
 
     QSet<QString> mPersonalNamespaces;
@@ -99,36 +99,36 @@ public:
     KAsync::Job<void> login(const QString &username, const QString &password);
     KAsync::Job<SelectResult> select(const QString &mailbox);
     KAsync::Job<qint64> append(const QString &mailbox, const QByteArray &content, const QList<QByteArray> &flags = QList<QByteArray>(), const QDateTime &internalDate = QDateTime());
-    KAsync::Job<void> store(const KIMAP::ImapSet &set, const QList<QByteArray> &flags);
-    KAsync::Job<void> storeFlags(const KIMAP::ImapSet &set, const QList<QByteArray> &flags);
-    KAsync::Job<void> addFlags(const KIMAP::ImapSet &set, const QList<QByteArray> &flags);
-    KAsync::Job<void> removeFlags(const KIMAP::ImapSet &set, const QList<QByteArray> &flags);
+    KAsync::Job<void> store(const KIMAP2::ImapSet &set, const QList<QByteArray> &flags);
+    KAsync::Job<void> storeFlags(const KIMAP2::ImapSet &set, const QList<QByteArray> &flags);
+    KAsync::Job<void> addFlags(const KIMAP2::ImapSet &set, const QList<QByteArray> &flags);
+    KAsync::Job<void> removeFlags(const KIMAP2::ImapSet &set, const QList<QByteArray> &flags);
     KAsync::Job<void> create(const QString &mailbox);
     KAsync::Job<void> rename(const QString &mailbox, const QString &newMailbox);
     KAsync::Job<void> remove(const QString &mailbox);
     KAsync::Job<void> expunge();
-    KAsync::Job<void> expunge(const KIMAP::ImapSet &set);
-    KAsync::Job<void> copy(const KIMAP::ImapSet &set, const QString &newMailbox);
-    KAsync::Job<QVector<qint64>> search(const KIMAP::ImapSet &set);
+    KAsync::Job<void> expunge(const KIMAP2::ImapSet &set);
+    KAsync::Job<void> copy(const KIMAP2::ImapSet &set, const QString &newMailbox);
+    KAsync::Job<QVector<qint64>> search(const KIMAP2::ImapSet &set);
 
     typedef std::function<void(const QString &,
                         const QMap<qint64,qint64> &,
                         const QMap<qint64,qint64> &,
-                        const QMap<qint64,KIMAP::MessageAttribute> &,
-                        const QMap<qint64,KIMAP::MessageFlags> &,
-                        const QMap<qint64,KIMAP::MessagePtr> &)> FetchCallback;
+                        const QMap<qint64,KIMAP2::MessageAttribute> &,
+                        const QMap<qint64,KIMAP2::MessageFlags> &,
+                        const QMap<qint64,KIMAP2::MessagePtr> &)> FetchCallback;
 
-    KAsync::Job<void> fetch(const KIMAP::ImapSet &set, KIMAP::FetchJob::FetchScope scope, FetchCallback callback);
-    KAsync::Job<void> fetch(const KIMAP::ImapSet &set, KIMAP::FetchJob::FetchScope scope, const std::function<void(const QVector<Message> &)> &callback);
-    KAsync::Job<void> list(KIMAP::ListJob::Option option, const std::function<void(const QList<KIMAP::MailBoxDescriptor> &mailboxes,const QList<QList<QByteArray> > &flags)> &callback);
+    KAsync::Job<void> fetch(const KIMAP2::ImapSet &set, KIMAP2::FetchJob::FetchScope scope, FetchCallback callback);
+    KAsync::Job<void> fetch(const KIMAP2::ImapSet &set, KIMAP2::FetchJob::FetchScope scope, const std::function<void(const QVector<Message> &)> &callback);
+    KAsync::Job<void> list(KIMAP2::ListJob::Option option, const std::function<void(const QList<KIMAP2::MailBoxDescriptor> &mailboxes,const QList<QList<QByteArray> > &flags)> &callback);
 
     QStringList getCapabilities() const;
 
     //Composed calls that do login etc.
     KAsync::Job<QList<qint64>> fetchHeaders(const QString &mailbox, qint64 minUid = 1);
-    KAsync::Job<void> remove(const QString &mailbox, const KIMAP::ImapSet &set);
+    KAsync::Job<void> remove(const QString &mailbox, const KIMAP2::ImapSet &set);
     KAsync::Job<void> remove(const QString &mailbox, const QByteArray &imapSet);
-    KAsync::Job<void> move(const QString &mailbox, const KIMAP::ImapSet &set, const QString &newMailbox);
+    KAsync::Job<void> move(const QString &mailbox, const KIMAP2::ImapSet &set, const QString &newMailbox);
     KAsync::Job<QString> createSubfolder(const QString &parentMailbox, const QString &folderName);
     KAsync::Job<QString> renameSubfolder(const QString &mailbox, const QString &newName);
     KAsync::Job<QVector<qint64>> fetchUids(const QString &mailbox);
diff --git a/examples/imapresource/tests/imapserverproxytest.cpp b/examples/imapresource/tests/imapserverproxytest.cpp
index 80dcbea..21c2248 100644
--- a/examples/imapresource/tests/imapserverproxytest.cpp
+++ b/examples/imapresource/tests/imapserverproxytest.cpp
@@ -73,16 +73,16 @@ private slots:
         ImapServerProxy imap("localhost", 993);
         VERIFYEXEC(imap.login("doe", "doe"));
 
-        KIMAP::FetchJob::FetchScope scope;
-        scope.mode = KIMAP::FetchJob::FetchScope::Headers;
+        KIMAP2::FetchJob::FetchScope scope;
+        scope.mode = KIMAP2::FetchJob::FetchScope::Headers;
         int count = 0;
-        auto job = imap.select("INBOX.test").then<void>(imap.fetch(KIMAP::ImapSet::fromImapSequenceSet("1:*"), scope,
+        auto job = imap.select("INBOX.test").then<void>(imap.fetch(KIMAP2::ImapSet::fromImapSequenceSet("1:*"), scope,
                     [&count](const QString &mailbox,
                             const QMap<qint64,qint64> &uids,
                             const QMap<qint64,qint64> &sizes,
-                            const QMap<qint64,KIMAP::MessageAttribute> &attrs,
-                            const QMap<qint64,KIMAP::MessageFlags> &flags,
-                            const QMap<qint64,KIMAP::MessagePtr> &messages) {
+                            const QMap<qint64,KIMAP2::MessageAttribute> &attrs,
+                            const QMap<qint64,KIMAP2::MessageFlags> &flags,
+                            const QMap<qint64,KIMAP2::MessagePtr> &messages) {
                         SinkTrace() << "Received " << uids.size() << " messages from " << mailbox;
                         SinkTrace() << uids.size() << sizes.size() << attrs.size() << flags.size() << messages.size();
                         count += uids.size();
@@ -98,16 +98,16 @@ private slots:
         VERIFYEXEC(imap.login("doe", "doe"));
         VERIFYEXEC(imap.remove("INBOX.test", "1:*"));
 
-        KIMAP::FetchJob::FetchScope scope;
-        scope.mode = KIMAP::FetchJob::FetchScope::Headers;
+        KIMAP2::FetchJob::FetchScope scope;
+        scope.mode = KIMAP2::FetchJob::FetchScope::Headers;
         int count = 0;
-        auto job = imap.select("INBOX.test").then<void>(imap.fetch(KIMAP::ImapSet::fromImapSequenceSet("1:*"), scope,
+        auto job = imap.select("INBOX.test").then<void>(imap.fetch(KIMAP2::ImapSet::fromImapSequenceSet("1:*"), scope,
                     [&count](const QString &mailbox,
                             const QMap<qint64,qint64> &uids,
                             const QMap<qint64,qint64> &sizes,
-                            const QMap<qint64,KIMAP::MessageAttribute> &attrs,
-                            const QMap<qint64,KIMAP::MessageFlags> &flags,
-                            const QMap<qint64,KIMAP::MessagePtr> &messages) {
+                            const QMap<qint64,KIMAP2::MessageAttribute> &attrs,
+                            const QMap<qint64,KIMAP2::MessageFlags> &flags,
+                            const QMap<qint64,KIMAP2::MessagePtr> &messages) {
                         SinkTrace() << "Received " << uids.size() << " messages from " << mailbox;
                         SinkTrace() << uids.size() << sizes.size() << attrs.size() << flags.size() << messages.size();
                         count += uids.size();