diff --git a/src/wayland/autotests/client/test_wayland_connection_thread.cpp b/src/wayland/autotests/client/test_wayland_connection_thread.cpp
index 5921abeb8c..d56ef93c8c 100644
--- a/src/wayland/autotests/client/test_wayland_connection_thread.cpp
+++ b/src/wayland/autotests/client/test_wayland_connection_thread.cpp
@@ -70,7 +70,7 @@ void TestWaylandConnectionThread::cleanup()
 
 void TestWaylandConnectionThread::testInitConnectionNoThread()
 {
-    QScopedPointer<KWin::Wayland::ConnectionThread> connection(new KWin::Wayland::ConnectionThread);
+    QScopedPointer<KWayland::Client::ConnectionThread> connection(new KWayland::Client::ConnectionThread);
     QCOMPARE(connection->socketName(), QStringLiteral("wayland-0"));
     connection->setSocketName(s_socketName);
     QCOMPARE(connection->socketName(), s_socketName);
@@ -86,7 +86,7 @@ void TestWaylandConnectionThread::testInitConnectionNoThread()
 
 void TestWaylandConnectionThread::testConnectionFailure()
 {
-    QScopedPointer<KWin::Wayland::ConnectionThread> connection(new KWin::Wayland::ConnectionThread);
+    QScopedPointer<KWayland::Client::ConnectionThread> connection(new KWayland::Client::ConnectionThread);
     connection->setSocketName(QStringLiteral("kwin-test-socket-does-not-exist"));
 
     QSignalSpy connectedSpy(connection.data(), SIGNAL(connected()));
@@ -122,7 +122,7 @@ static const struct wl_registry_listener s_registryListener = {
 
 void TestWaylandConnectionThread::testConnectionThread()
 {
-    QScopedPointer<KWin::Wayland::ConnectionThread> connection(new KWin::Wayland::ConnectionThread);
+    QScopedPointer<KWayland::Client::ConnectionThread> connection(new KWayland::Client::ConnectionThread);
     connection->setSocketName(s_socketName);
 
     QThread *connectionThread = new QThread(this);
@@ -163,7 +163,7 @@ void TestWaylandConnectionThread::testConnectionThread()
 
 void TestWaylandConnectionThread::testConnectionDieing()
 {
-    QScopedPointer<KWin::Wayland::ConnectionThread> connection(new KWin::Wayland::ConnectionThread);
+    QScopedPointer<KWayland::Client::ConnectionThread> connection(new KWayland::Client::ConnectionThread);
     QSignalSpy connectedSpy(connection.data(), SIGNAL(connected()));
     connection->setSocketName(s_socketName);
     connection->initConnection();
diff --git a/src/wayland/autotests/client/test_wayland_fullscreen_shell.cpp b/src/wayland/autotests/client/test_wayland_fullscreen_shell.cpp
index 77cde84932..93cdfe004a 100644
--- a/src/wayland/autotests/client/test_wayland_fullscreen_shell.cpp
+++ b/src/wayland/autotests/client/test_wayland_fullscreen_shell.cpp
@@ -96,13 +96,13 @@ void TestWaylandFullscreenShell::testRegistry()
     if (m_westonProcess->state() != QProcess::Running) {
         QSKIP("This test requires a running wayland server");
     }
-    KWin::Wayland::ConnectionThread connection;
+    KWayland::Client::ConnectionThread connection;
     QSignalSpy connectedSpy(&connection, SIGNAL(connected()));
     connection.setSocketName(s_socketName);
     connection.initConnection();
     QVERIFY(connectedSpy.wait());
 
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy announced(&registry, SIGNAL(fullscreenShellAnnounced(quint32,quint32)));
     registry.create(connection.display());
     QVERIFY(registry.isValid());
@@ -110,7 +110,7 @@ void TestWaylandFullscreenShell::testRegistry()
     wl_display_flush(connection.display());
     QVERIFY(announced.wait());
 
-    KWin::Wayland::FullscreenShell fullscreenShell;
+    KWayland::Client::FullscreenShell fullscreenShell;
     QVERIFY(!fullscreenShell.isValid());
     QVERIFY(!fullscreenShell.hasCapabilityArbitraryModes());
     QVERIFY(!fullscreenShell.hasCapabilityCursorPlane());
diff --git a/src/wayland/autotests/client/test_wayland_output.cpp b/src/wayland/autotests/client/test_wayland_output.cpp
index 14a162f31f..3505fb2dd0 100644
--- a/src/wayland/autotests/client/test_wayland_output.cpp
+++ b/src/wayland/autotests/client/test_wayland_output.cpp
@@ -50,7 +50,7 @@ private Q_SLOTS:
 private:
     KWayland::Server::Display *m_display;
     KWayland::Server::OutputInterface *m_serverOutput;
-    KWin::Wayland::ConnectionThread *m_connection;
+    KWayland::Client::ConnectionThread *m_connection;
     QThread *m_thread;
 };
 
@@ -82,7 +82,7 @@ void TestWaylandOutput::init()
     m_serverOutput->create();
 
     // setup connection
-    m_connection = new KWin::Wayland::ConnectionThread;
+    m_connection = new KWayland::Client::ConnectionThread;
     QSignalSpy connectedSpy(m_connection, SIGNAL(connected()));
     m_connection->setSocketName(s_socketName);
 
@@ -117,7 +117,7 @@ void TestWaylandOutput::testRegistry()
     m_serverOutput->setGlobalPosition(QPoint(100, 50));
     m_serverOutput->setPhysicalSize(QSize(200, 100));
 
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy announced(&registry, SIGNAL(outputAnnounced(quint32,quint32)));
     registry.create(m_connection->display());
     QVERIFY(registry.isValid());
@@ -125,7 +125,7 @@ void TestWaylandOutput::testRegistry()
     wl_display_flush(m_connection->display());
     QVERIFY(announced.wait());
 
-    KWin::Wayland::Output output;
+    KWayland::Client::Output output;
     QVERIFY(!output.isValid());
     QCOMPARE(output.geometry(), QRect());
     QCOMPARE(output.globalPosition(), QPoint());
@@ -135,8 +135,8 @@ void TestWaylandOutput::testRegistry()
     QCOMPARE(output.pixelSize(), QSize());
     QCOMPARE(output.refreshRate(), 0);
     QCOMPARE(output.scale(), 1);
-    QCOMPARE(output.subPixel(), KWin::Wayland::Output::SubPixel::Unknown);
-    QCOMPARE(output.transform(), KWin::Wayland::Output::Transform::Normal);
+    QCOMPARE(output.subPixel(), KWayland::Client::Output::SubPixel::Unknown);
+    QCOMPARE(output.transform(), KWayland::Client::Output::Transform::Normal);
 
     QSignalSpy outputChanged(&output, SIGNAL(changed()));
     QVERIFY(outputChanged.isValid());
@@ -154,14 +154,14 @@ void TestWaylandOutput::testRegistry()
     QCOMPARE(output.refreshRate(), 60000);
     QCOMPARE(output.scale(), 1);
     // for xwayland output it's unknown
-    QCOMPARE(output.subPixel(), KWin::Wayland::Output::SubPixel::Unknown);
+    QCOMPARE(output.subPixel(), KWayland::Client::Output::SubPixel::Unknown);
     // for xwayland transform is normal
-    QCOMPARE(output.transform(), KWin::Wayland::Output::Transform::Normal);
+    QCOMPARE(output.transform(), KWayland::Client::Output::Transform::Normal);
 }
 
 void TestWaylandOutput::testModeChanges()
 {
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy announced(&registry, SIGNAL(outputAnnounced(quint32,quint32)));
     registry.create(m_connection->display());
     QVERIFY(registry.isValid());
@@ -169,7 +169,7 @@ void TestWaylandOutput::testModeChanges()
     wl_display_flush(m_connection->display());
     QVERIFY(announced.wait());
 
-    KWin::Wayland::Output output;
+    KWayland::Client::Output output;
     QSignalSpy outputChanged(&output, SIGNAL(changed()));
     QVERIFY(outputChanged.isValid());
     output.setup(registry.bindOutput(announced.first().first().value<quint32>(), announced.first().last().value<quint32>()));
@@ -193,7 +193,7 @@ void TestWaylandOutput::testModeChanges()
 
 void TestWaylandOutput::testScaleChange()
 {
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy announced(&registry, SIGNAL(outputAnnounced(quint32,quint32)));
     registry.create(m_connection->display());
     QVERIFY(registry.isValid());
@@ -201,7 +201,7 @@ void TestWaylandOutput::testScaleChange()
     wl_display_flush(m_connection->display());
     QVERIFY(announced.wait());
 
-    KWin::Wayland::Output output;
+    KWayland::Client::Output output;
     QSignalSpy outputChanged(&output, SIGNAL(changed()));
     QVERIFY(outputChanged.isValid());
     output.setup(registry.bindOutput(announced.first().first().value<quint32>(), announced.first().last().value<quint32>()));
@@ -224,9 +224,9 @@ void TestWaylandOutput::testScaleChange()
 
 void TestWaylandOutput::testSubPixel_data()
 {
-    using namespace KWin::Wayland;
+    using namespace KWayland::Client;
     using namespace KWayland::Server;
-    QTest::addColumn<KWin::Wayland::Output::SubPixel>("expected");
+    QTest::addColumn<KWayland::Client::Output::SubPixel>("expected");
     QTest::addColumn<KWayland::Server::OutputInterface::SubPixel>("actual");
 
     QTest::newRow("none") << Output::SubPixel::None << OutputInterface::SubPixel::None;
@@ -238,12 +238,12 @@ void TestWaylandOutput::testSubPixel_data()
 
 void TestWaylandOutput::testSubPixel()
 {
-    using namespace KWin::Wayland;
+    using namespace KWayland::Client;
     using namespace KWayland::Server;
     QFETCH(OutputInterface::SubPixel, actual);
     m_serverOutput->setSubPixel(actual);
 
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy announced(&registry, SIGNAL(outputAnnounced(quint32,quint32)));
     registry.create(m_connection->display());
     QVERIFY(registry.isValid());
@@ -251,7 +251,7 @@ void TestWaylandOutput::testSubPixel()
     wl_display_flush(m_connection->display());
     QVERIFY(announced.wait());
 
-    KWin::Wayland::Output output;
+    KWayland::Client::Output output;
     QSignalSpy outputChanged(&output, SIGNAL(changed()));
     QVERIFY(outputChanged.isValid());
     output.setup(registry.bindOutput(announced.first().first().value<quint32>(), announced.first().last().value<quint32>()));
@@ -273,9 +273,9 @@ void TestWaylandOutput::testSubPixel()
 
 void TestWaylandOutput::testTransform_data()
 {
-    using namespace KWin::Wayland;
+    using namespace KWayland::Client;
     using namespace KWayland::Server;
-    QTest::addColumn<KWin::Wayland::Output::Transform>("expected");
+    QTest::addColumn<KWayland::Client::Output::Transform>("expected");
     QTest::addColumn<KWayland::Server::OutputInterface::Transform>("actual");
 
     QTest::newRow("90")          << Output::Transform::Rotated90  << OutputInterface::Transform::Rotated90;
@@ -289,12 +289,12 @@ void TestWaylandOutput::testTransform_data()
 
 void TestWaylandOutput::testTransform()
 {
-    using namespace KWin::Wayland;
+    using namespace KWayland::Client;
     using namespace KWayland::Server;
     QFETCH(OutputInterface::Transform, actual);
     m_serverOutput->setTransform(actual);
 
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy announced(&registry, SIGNAL(outputAnnounced(quint32,quint32)));
     registry.create(m_connection->display());
     QVERIFY(registry.isValid());
@@ -302,7 +302,7 @@ void TestWaylandOutput::testTransform()
     wl_display_flush(m_connection->display());
     QVERIFY(announced.wait());
 
-    KWin::Wayland::Output output;
+    KWayland::Client::Output output;
     QSignalSpy outputChanged(&output, SIGNAL(changed()));
     QVERIFY(outputChanged.isValid());
     output.setup(registry.bindOutput(announced.first().first().value<quint32>(), announced.first().last().value<quint32>()));
diff --git a/src/wayland/autotests/client/test_wayland_registry.cpp b/src/wayland/autotests/client/test_wayland_registry.cpp
index 6d6d556acf..c9d9e25a20 100644
--- a/src/wayland/autotests/client/test_wayland_registry.cpp
+++ b/src/wayland/autotests/client/test_wayland_registry.cpp
@@ -91,13 +91,13 @@ void TestWaylandRegistry::cleanup()
 
 void TestWaylandRegistry::testCreate()
 {
-    KWin::Wayland::ConnectionThread connection;
+    KWayland::Client::ConnectionThread connection;
     QSignalSpy connectedSpy(&connection, SIGNAL(connected()));
     connection.setSocketName(s_socketName);
     connection.initConnection();
     QVERIFY(connectedSpy.wait());
 
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QVERIFY(!registry.isValid());
     registry.create(connection.display());
     QVERIFY(registry.isValid());
@@ -106,13 +106,13 @@ void TestWaylandRegistry::testCreate()
 }
 
 #define TEST_BIND(interface, signalName, bindMethod, destroyFunction) \
-    KWin::Wayland::ConnectionThread connection; \
+    KWayland::Client::ConnectionThread connection; \
     QSignalSpy connectedSpy(&connection, SIGNAL(connected())); \
     connection.setSocketName(s_socketName); \
     connection.initConnection(); \
     QVERIFY(connectedSpy.wait()); \
     \
-    KWin::Wayland::Registry registry; \
+    KWayland::Client::Registry registry; \
     /* before registry is created, we cannot bind the interface*/ \
     QVERIFY(!registry.bindMethod(0, 0)); \
     \
@@ -141,34 +141,34 @@ void TestWaylandRegistry::testCreate()
 
 void TestWaylandRegistry::testBindCompositor()
 {
-    TEST_BIND(KWin::Wayland::Registry::Interface::Compositor, SIGNAL(compositorAnnounced(quint32,quint32)), bindCompositor, wl_compositor_destroy)
+    TEST_BIND(KWayland::Client::Registry::Interface::Compositor, SIGNAL(compositorAnnounced(quint32,quint32)), bindCompositor, wl_compositor_destroy)
 }
 
 void TestWaylandRegistry::testBindShell()
 {
-    TEST_BIND(KWin::Wayland::Registry::Interface::Shell, SIGNAL(shellAnnounced(quint32,quint32)), bindShell, free)
+    TEST_BIND(KWayland::Client::Registry::Interface::Shell, SIGNAL(shellAnnounced(quint32,quint32)), bindShell, free)
 }
 
 void TestWaylandRegistry::testBindOutput()
 {
-    TEST_BIND(KWin::Wayland::Registry::Interface::Output, SIGNAL(outputAnnounced(quint32,quint32)), bindOutput, wl_output_destroy)
+    TEST_BIND(KWayland::Client::Registry::Interface::Output, SIGNAL(outputAnnounced(quint32,quint32)), bindOutput, wl_output_destroy)
 }
 
 void TestWaylandRegistry::testBindSeat()
 {
-    TEST_BIND(KWin::Wayland::Registry::Interface::Seat, SIGNAL(seatAnnounced(quint32,quint32)), bindSeat, wl_seat_destroy)
+    TEST_BIND(KWayland::Client::Registry::Interface::Seat, SIGNAL(seatAnnounced(quint32,quint32)), bindSeat, wl_seat_destroy)
 }
 
 void TestWaylandRegistry::testBindShm()
 {
-    TEST_BIND(KWin::Wayland::Registry::Interface::Shm, SIGNAL(shmAnnounced(quint32,quint32)), bindShm, wl_shm_destroy)
+    TEST_BIND(KWayland::Client::Registry::Interface::Shm, SIGNAL(shmAnnounced(quint32,quint32)), bindShm, wl_shm_destroy)
 }
 
 #undef TEST_BIND
 
 void TestWaylandRegistry::testRemoval()
 {
-    KWin::Wayland::ConnectionThread connection;
+    KWayland::Client::ConnectionThread connection;
     QSignalSpy connectedSpy(&connection, SIGNAL(connected()));
     connection.setSocketName(s_socketName);
     connection.initConnection();
@@ -179,7 +179,7 @@ void TestWaylandRegistry::testRemoval()
         }
     );
 
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy shmAnnouncedSpy(&registry, SIGNAL(shmAnnounced(quint32,quint32)));
     QVERIFY(shmAnnouncedSpy.isValid());
     QSignalSpy compositorAnnouncedSpy(&registry, SIGNAL(compositorAnnounced(quint32,quint32)));
@@ -201,12 +201,12 @@ void TestWaylandRegistry::testRemoval()
     QVERIFY(!shellAnnouncedSpy.isEmpty());
     QVERIFY(!seatAnnouncedSpy.isEmpty());
 
-    QVERIFY(registry.hasInterface(KWin::Wayland::Registry::Interface::Compositor));
-    QVERIFY(registry.hasInterface(KWin::Wayland::Registry::Interface::Output));
-    QVERIFY(registry.hasInterface(KWin::Wayland::Registry::Interface::Seat));
-    QVERIFY(registry.hasInterface(KWin::Wayland::Registry::Interface::Shell));
-    QVERIFY(registry.hasInterface(KWin::Wayland::Registry::Interface::Shm));
-    QVERIFY(!registry.hasInterface(KWin::Wayland::Registry::Interface::FullscreenShell));
+    QVERIFY(registry.hasInterface(KWayland::Client::Registry::Interface::Compositor));
+    QVERIFY(registry.hasInterface(KWayland::Client::Registry::Interface::Output));
+    QVERIFY(registry.hasInterface(KWayland::Client::Registry::Interface::Seat));
+    QVERIFY(registry.hasInterface(KWayland::Client::Registry::Interface::Shell));
+    QVERIFY(registry.hasInterface(KWayland::Client::Registry::Interface::Shm));
+    QVERIFY(!registry.hasInterface(KWayland::Client::Registry::Interface::FullscreenShell));
 
     QSignalSpy seatRemovedSpy(&registry, SIGNAL(seatRemoved(quint32)));
     QVERIFY(seatRemovedSpy.isValid());
@@ -214,7 +214,7 @@ void TestWaylandRegistry::testRemoval()
     delete m_seat;
     QVERIFY(seatRemovedSpy.wait());
     QCOMPARE(seatRemovedSpy.first().first(), seatAnnouncedSpy.first().first());
-    QVERIFY(!registry.hasInterface(KWin::Wayland::Registry::Interface::Seat));
+    QVERIFY(!registry.hasInterface(KWayland::Client::Registry::Interface::Seat));
 
     QSignalSpy shellRemovedSpy(&registry, SIGNAL(shellRemoved(quint32)));
     QVERIFY(shellRemovedSpy.isValid());
@@ -222,7 +222,7 @@ void TestWaylandRegistry::testRemoval()
     delete m_shell;
     QVERIFY(shellRemovedSpy.wait());
     QCOMPARE(shellRemovedSpy.first().first(), shellAnnouncedSpy.first().first());
-    QVERIFY(!registry.hasInterface(KWin::Wayland::Registry::Interface::Shell));
+    QVERIFY(!registry.hasInterface(KWayland::Client::Registry::Interface::Shell));
 
     QSignalSpy outputRemovedSpy(&registry, SIGNAL(outputRemoved(quint32)));
     QVERIFY(outputRemovedSpy.isValid());
@@ -230,7 +230,7 @@ void TestWaylandRegistry::testRemoval()
     delete m_output;
     QVERIFY(outputRemovedSpy.wait());
     QCOMPARE(outputRemovedSpy.first().first(), outputAnnouncedSpy.first().first());
-    QVERIFY(!registry.hasInterface(KWin::Wayland::Registry::Interface::Output));
+    QVERIFY(!registry.hasInterface(KWayland::Client::Registry::Interface::Output));
 
     QSignalSpy compositorRemovedSpy(&registry, SIGNAL(compositorRemoved(quint32)));
     QVERIFY(compositorRemovedSpy.isValid());
@@ -238,7 +238,7 @@ void TestWaylandRegistry::testRemoval()
     delete m_compositor;
     QVERIFY(compositorRemovedSpy.wait());
     QCOMPARE(compositorRemovedSpy.first().first(), compositorAnnouncedSpy.first().first());
-    QVERIFY(!registry.hasInterface(KWin::Wayland::Registry::Interface::Compositor));
+    QVERIFY(!registry.hasInterface(KWayland::Client::Registry::Interface::Compositor));
 
     // cannot test shmRemoved as there is no functionality for it
 }
diff --git a/src/wayland/autotests/client/test_wayland_seat.cpp b/src/wayland/autotests/client/test_wayland_seat.cpp
index d88e905901..b227999573 100644
--- a/src/wayland/autotests/client/test_wayland_seat.cpp
+++ b/src/wayland/autotests/client/test_wayland_seat.cpp
@@ -58,9 +58,9 @@ private:
     KWayland::Server::Display *m_display;
     KWayland::Server::CompositorInterface *m_compositorInterface;
     KWayland::Server::SeatInterface *m_seatInterface;
-    KWin::Wayland::ConnectionThread *m_connection;
-    KWin::Wayland::Compositor *m_compositor;
-    KWin::Wayland::Seat *m_seat;
+    KWayland::Client::ConnectionThread *m_connection;
+    KWayland::Client::Compositor *m_compositor;
+    KWayland::Client::Seat *m_seat;
     QThread *m_thread;
 };
 
@@ -93,7 +93,7 @@ void TestWaylandSeat::init()
     QVERIFY(m_compositorInterface->isValid());
 
     // setup connection
-    m_connection = new KWin::Wayland::ConnectionThread;
+    m_connection = new KWayland::Client::ConnectionThread;
     QSignalSpy connectedSpy(m_connection, SIGNAL(connected()));
     m_connection->setSocketName(s_socketName);
 
@@ -113,14 +113,14 @@ void TestWaylandSeat::init()
     QVERIFY(connectedSpy.wait());
     // TODO: we should destroy the queue
     wl_event_queue *queue = wl_display_create_queue(m_connection->display());
-    connect(m_connection, &KWin::Wayland::ConnectionThread::eventsRead, this,
+    connect(m_connection, &KWayland::Client::ConnectionThread::eventsRead, this,
         [this, queue]() {
             wl_display_dispatch_queue_pending(m_connection->display(), queue);
             wl_display_flush(m_connection->display());
         },
         Qt::QueuedConnection);
 
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy compositorSpy(&registry, SIGNAL(compositorAnnounced(quint32,quint32)));
     QSignalSpy seatSpy(&registry, SIGNAL(seatAnnounced(quint32,quint32)));
     registry.create(m_connection->display());
@@ -136,11 +136,11 @@ void TestWaylandSeat::init()
     QVERIFY(m_seatInterface->isValid());
     QVERIFY(seatSpy.wait());
 
-    m_compositor = new KWin::Wayland::Compositor(this);
+    m_compositor = new KWayland::Client::Compositor(this);
     m_compositor->setup(registry.bindCompositor(compositorSpy.first().first().value<quint32>(), compositorSpy.first().last().value<quint32>()));
     QVERIFY(m_compositor->isValid());
 
-    m_seat = new KWin::Wayland::Seat(this);
+    m_seat = new KWayland::Client::Seat(this);
     QSignalSpy nameSpy(m_seat, SIGNAL(nameChanged(QString)));
     m_seat->setup(registry.bindSeat(seatSpy.first().first().value<quint32>(), seatSpy.first().last().value<quint32>()));
     QVERIFY(nameSpy.wait());
@@ -258,7 +258,7 @@ void TestWaylandSeat::testCapabilities()
 
 void TestWaylandSeat::testPointer()
 {
-    using namespace KWin::Wayland;
+    using namespace KWayland::Client;
     using namespace KWayland::Server;
 
     QSignalSpy pointerSpy(m_seat, SIGNAL(hasPointerChanged(bool)));
@@ -292,10 +292,10 @@ void TestWaylandSeat::testPointer()
     QSignalSpy motionSpy(p, SIGNAL(motion(QPointF,quint32)));
     QVERIFY(motionSpy.isValid());
 
-    QSignalSpy axisSpy(p, SIGNAL(axisChanged(quint32,KWin::Wayland::Pointer::Axis,qreal)));
+    QSignalSpy axisSpy(p, SIGNAL(axisChanged(quint32,KWayland::Client::Pointer::Axis,qreal)));
     QVERIFY(axisSpy.isValid());
 
-    QSignalSpy buttonSpy(p, SIGNAL(buttonStateChanged(quint32,quint32,quint32,KWin::Wayland::Pointer::ButtonState)));
+    QSignalSpy buttonSpy(p, SIGNAL(buttonStateChanged(quint32,quint32,quint32,KWayland::Client::Pointer::ButtonState)));
     QVERIFY(buttonSpy.isValid());
 
     serverPointer->setFocusedSurface(serverSurface, QPoint(10, 15));
@@ -348,27 +348,27 @@ void TestWaylandSeat::testPointer()
     QCOMPARE(buttonSpy.at(0).at(1).value<quint32>(), quint32(4));
     // button
     QCOMPARE(buttonSpy.at(0).at(2).value<quint32>(), quint32(1));
-    QCOMPARE(buttonSpy.at(0).at(3).value<KWin::Wayland::Pointer::ButtonState>(), KWin::Wayland::Pointer::ButtonState::Pressed);
+    QCOMPARE(buttonSpy.at(0).at(3).value<KWayland::Client::Pointer::ButtonState>(), KWayland::Client::Pointer::ButtonState::Pressed);
 
     // timestamp
     QCOMPARE(buttonSpy.at(1).at(1).value<quint32>(), quint32(5));
     // button
     QCOMPARE(buttonSpy.at(1).at(2).value<quint32>(), quint32(2));
-    QCOMPARE(buttonSpy.at(1).at(3).value<KWin::Wayland::Pointer::ButtonState>(), KWin::Wayland::Pointer::ButtonState::Pressed);
+    QCOMPARE(buttonSpy.at(1).at(3).value<KWayland::Client::Pointer::ButtonState>(), KWayland::Client::Pointer::ButtonState::Pressed);
 
     QCOMPARE(buttonSpy.at(2).at(0).value<quint32>(), serverPointer->buttonSerial(2));
     // timestamp
     QCOMPARE(buttonSpy.at(2).at(1).value<quint32>(), quint32(6));
     // button
     QCOMPARE(buttonSpy.at(2).at(2).value<quint32>(), quint32(2));
-    QCOMPARE(buttonSpy.at(2).at(3).value<KWin::Wayland::Pointer::ButtonState>(), KWin::Wayland::Pointer::ButtonState::Released);
+    QCOMPARE(buttonSpy.at(2).at(3).value<KWayland::Client::Pointer::ButtonState>(), KWayland::Client::Pointer::ButtonState::Released);
 
     QCOMPARE(buttonSpy.at(3).at(0).value<quint32>(), serverPointer->buttonSerial(1));
     // timestamp
     QCOMPARE(buttonSpy.at(3).at(1).value<quint32>(), quint32(7));
     // button
     QCOMPARE(buttonSpy.at(3).at(2).value<quint32>(), quint32(1));
-    QCOMPARE(buttonSpy.at(3).at(3).value<KWin::Wayland::Pointer::ButtonState>(), KWin::Wayland::Pointer::ButtonState::Released);
+    QCOMPARE(buttonSpy.at(3).at(3).value<KWayland::Client::Pointer::ButtonState>(), KWayland::Client::Pointer::ButtonState::Released);
 
     // leave the surface
     serverPointer->setFocusedSurface(nullptr);
@@ -387,7 +387,7 @@ void TestWaylandSeat::testPointer()
 
 void TestWaylandSeat::testKeyboard()
 {
-    using namespace KWin::Wayland;
+    using namespace KWayland::Client;
     using namespace KWayland::Server;
 
     QSignalSpy keyboardSpy(m_seat, SIGNAL(hasKeyboardChanged(bool)));
@@ -436,7 +436,7 @@ void TestWaylandSeat::testKeyboard()
     QCOMPARE(modifierSpy.first().at(2).value<quint32>(), quint32(0));
     QCOMPARE(modifierSpy.first().at(3).value<quint32>(), quint32(0));
 
-    QSignalSpy keyChangedSpy(keyboard, SIGNAL(keyChanged(quint32,KWin::Wayland::Keyboard::KeyState,quint32)));
+    QSignalSpy keyChangedSpy(keyboard, SIGNAL(keyChanged(quint32,KWayland::Client::Keyboard::KeyState,quint32)));
     QVERIFY(keyChangedSpy.isValid());
 
     serverKeyboard->updateTimestamp(4);
diff --git a/src/wayland/autotests/client/test_wayland_shell.cpp b/src/wayland/autotests/client/test_wayland_shell.cpp
index 1c4ef0e364..09454b5809 100644
--- a/src/wayland/autotests/client/test_wayland_shell.cpp
+++ b/src/wayland/autotests/client/test_wayland_shell.cpp
@@ -51,9 +51,9 @@ private:
     KWayland::Server::Display *m_display;
     KWayland::Server::CompositorInterface *m_compositorInterface;
     KWayland::Server::ShellInterface *m_shellInterface;
-    KWin::Wayland::ConnectionThread *m_connection;
-    KWin::Wayland::Compositor *m_compositor;
-    KWin::Wayland::Shell *m_shell;
+    KWayland::Client::ConnectionThread *m_connection;
+    KWayland::Client::Compositor *m_compositor;
+    KWayland::Client::Shell *m_shell;
     QThread *m_thread;
 };
 
@@ -91,7 +91,7 @@ void TestWaylandShell::init()
     QVERIFY(m_shellInterface->isValid());
 
     // setup connection
-    m_connection = new KWin::Wayland::ConnectionThread;
+    m_connection = new KWayland::Client::ConnectionThread;
     QSignalSpy connectedSpy(m_connection, SIGNAL(connected()));
     m_connection->setSocketName(s_socketName);
 
@@ -111,14 +111,14 @@ void TestWaylandShell::init()
     QVERIFY(connectedSpy.wait());
     // TODO: we should destroy the queue
     wl_event_queue *queue = wl_display_create_queue(m_connection->display());
-    connect(m_connection, &KWin::Wayland::ConnectionThread::eventsRead, this,
+    connect(m_connection, &KWayland::Client::ConnectionThread::eventsRead, this,
         [this, queue]() {
             wl_display_dispatch_queue_pending(m_connection->display(), queue);
             wl_display_flush(m_connection->display());
         },
         Qt::QueuedConnection);
 
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy compositorSpy(&registry, SIGNAL(compositorAnnounced(quint32,quint32)));
     QSignalSpy shellSpy(&registry, SIGNAL(shellAnnounced(quint32,quint32)));
     registry.create(m_connection->display());
@@ -127,14 +127,14 @@ void TestWaylandShell::init()
     wl_proxy_set_queue((wl_proxy*)registry.registry(), queue);
     QVERIFY(compositorSpy.wait());
 
-    m_compositor = new KWin::Wayland::Compositor(this);
+    m_compositor = new KWayland::Client::Compositor(this);
     m_compositor->setup(registry.bindCompositor(compositorSpy.first().first().value<quint32>(), compositorSpy.first().last().value<quint32>()));
     QVERIFY(m_compositor->isValid());
 
     if (shellSpy.isEmpty()) {
         QVERIFY(shellSpy.wait());
     }
-    m_shell = new KWin::Wayland::Shell(this);
+    m_shell = new KWayland::Client::Shell(this);
     m_shell->setup(registry.bindShell(shellSpy.first().first().value<quint32>(), shellSpy.first().last().value<quint32>()));
     QVERIFY(m_shell->isValid());
 }
@@ -171,10 +171,10 @@ void TestWaylandShell::cleanup()
 void TestWaylandShell::testFullscreen()
 {
     using namespace KWayland::Server;
-    QScopedPointer<KWin::Wayland::Surface> s(m_compositor->createSurface());
+    QScopedPointer<KWayland::Client::Surface> s(m_compositor->createSurface());
     QVERIFY(!s.isNull());
     QVERIFY(s->isValid());
-    KWin::Wayland::ShellSurface *surface = m_shell->createSurface(s.data(), m_shell);
+    KWayland::Client::ShellSurface *surface = m_shell->createSurface(s.data(), m_shell);
     QSignalSpy sizeSpy(surface, SIGNAL(sizeChanged(QSize)));
     QVERIFY(sizeSpy.isValid());
     QCOMPARE(surface->size(), QSize());
@@ -210,10 +210,10 @@ void TestWaylandShell::testFullscreen()
 void TestWaylandShell::testPing()
 {
     using namespace KWayland::Server;
-    QScopedPointer<KWin::Wayland::Surface> s(m_compositor->createSurface());
+    QScopedPointer<KWayland::Client::Surface> s(m_compositor->createSurface());
     QVERIFY(!s.isNull());
     QVERIFY(s->isValid());
-    KWin::Wayland::ShellSurface *surface = m_shell->createSurface(s.data(), m_shell);
+    KWayland::Client::ShellSurface *surface = m_shell->createSurface(s.data(), m_shell);
     QSignalSpy pingSpy(surface, SIGNAL(pinged()));
 
     QSignalSpy serverSurfaceSpy(m_shellInterface, SIGNAL(surfaceCreated(KWayland::Server::ShellSurfaceInterface*)));
@@ -253,10 +253,10 @@ void TestWaylandShell::testPing()
 void TestWaylandShell::testTitle()
 {
     using namespace KWayland::Server;
-    QScopedPointer<KWin::Wayland::Surface> s(m_compositor->createSurface());
+    QScopedPointer<KWayland::Client::Surface> s(m_compositor->createSurface());
     QVERIFY(!s.isNull());
     QVERIFY(s->isValid());
-    KWin::Wayland::ShellSurface *surface = m_shell->createSurface(s.data(), m_shell);
+    KWayland::Client::ShellSurface *surface = m_shell->createSurface(s.data(), m_shell);
 
     QSignalSpy serverSurfaceSpy(m_shellInterface, SIGNAL(surfaceCreated(KWayland::Server::ShellSurfaceInterface*)));
     QVERIFY(serverSurfaceSpy.isValid());
@@ -278,10 +278,10 @@ void TestWaylandShell::testTitle()
 void TestWaylandShell::testWindowClass()
 {
     using namespace KWayland::Server;
-    QScopedPointer<KWin::Wayland::Surface> s(m_compositor->createSurface());
+    QScopedPointer<KWayland::Client::Surface> s(m_compositor->createSurface());
     QVERIFY(!s.isNull());
     QVERIFY(s->isValid());
-    KWin::Wayland::ShellSurface *surface = m_shell->createSurface(s.data(), m_shell);
+    KWayland::Client::ShellSurface *surface = m_shell->createSurface(s.data(), m_shell);
 
     QSignalSpy serverSurfaceSpy(m_shellInterface, SIGNAL(surfaceCreated(KWayland::Server::ShellSurfaceInterface*)));
     QVERIFY(serverSurfaceSpy.isValid());
diff --git a/src/wayland/autotests/client/test_wayland_surface.cpp b/src/wayland/autotests/client/test_wayland_surface.cpp
index 4d196c6d49..1442f54c17 100644
--- a/src/wayland/autotests/client/test_wayland_surface.cpp
+++ b/src/wayland/autotests/client/test_wayland_surface.cpp
@@ -50,8 +50,8 @@ private Q_SLOTS:
 private:
     KWayland::Server::Display *m_display;
     KWayland::Server::CompositorInterface *m_compositorInterface;
-    KWin::Wayland::ConnectionThread *m_connection;
-    KWin::Wayland::Compositor *m_compositor;
+    KWayland::Client::ConnectionThread *m_connection;
+    KWayland::Client::Compositor *m_compositor;
     QThread *m_thread;
 };
 
@@ -82,7 +82,7 @@ void TestWaylandSurface::init()
     QVERIFY(m_compositorInterface->isValid());
 
     // setup connection
-    m_connection = new KWin::Wayland::ConnectionThread;
+    m_connection = new KWayland::Client::ConnectionThread;
     QSignalSpy connectedSpy(m_connection, SIGNAL(connected()));
     m_connection->setSocketName(s_socketName);
 
@@ -101,14 +101,14 @@ void TestWaylandSurface::init()
     m_connection->initConnection();
     QVERIFY(connectedSpy.wait());
 
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy compositorSpy(&registry, SIGNAL(compositorAnnounced(quint32,quint32)));
     registry.create(m_connection->display());
     QVERIFY(registry.isValid());
     registry.setup();
     QVERIFY(compositorSpy.wait());
 
-    m_compositor = new KWin::Wayland::Compositor(this);
+    m_compositor = new KWayland::Client::Compositor(this);
     m_compositor->setup(registry.bindCompositor(compositorSpy.first().first().value<quint32>(), compositorSpy.first().last().value<quint32>()));
     QVERIFY(m_compositor->isValid());
 }
@@ -140,12 +140,12 @@ void TestWaylandSurface::testStaticAccessor()
     QSignalSpy serverSurfaceCreated(m_compositorInterface, SIGNAL(surfaceCreated(KWayland::Server::SurfaceInterface*)));
     QVERIFY(serverSurfaceCreated.isValid());
 
-    QVERIFY(KWin::Wayland::Surface::all().isEmpty());
-    KWin::Wayland::Surface *s1 = m_compositor->createSurface();
+    QVERIFY(KWayland::Client::Surface::all().isEmpty());
+    KWayland::Client::Surface *s1 = m_compositor->createSurface();
     QVERIFY(s1->isValid());
-    QCOMPARE(KWin::Wayland::Surface::all().count(), 1);
-    QCOMPARE(KWin::Wayland::Surface::all().first(), s1);
-    QCOMPARE(KWin::Wayland::Surface::get(*s1), s1);
+    QCOMPARE(KWayland::Client::Surface::all().count(), 1);
+    QCOMPARE(KWayland::Client::Surface::all().first(), s1);
+    QCOMPARE(KWayland::Client::Surface::get(*s1), s1);
     QVERIFY(serverSurfaceCreated.wait());
 
     QVERIFY(!s1->size().isValid());
@@ -158,33 +158,33 @@ void TestWaylandSurface::testStaticAccessor()
     QCOMPARE(sizeChangedSpy.first().first().toSize(), testSize);
 
     // add another surface
-    KWin::Wayland::Surface *s2 = m_compositor->createSurface();
+    KWayland::Client::Surface *s2 = m_compositor->createSurface();
     QVERIFY(s2->isValid());
-    QCOMPARE(KWin::Wayland::Surface::all().count(), 2);
-    QCOMPARE(KWin::Wayland::Surface::all().first(), s1);
-    QCOMPARE(KWin::Wayland::Surface::all().last(), s2);
-    QCOMPARE(KWin::Wayland::Surface::get(*s1), s1);
-    QCOMPARE(KWin::Wayland::Surface::get(*s2), s2);
+    QCOMPARE(KWayland::Client::Surface::all().count(), 2);
+    QCOMPARE(KWayland::Client::Surface::all().first(), s1);
+    QCOMPARE(KWayland::Client::Surface::all().last(), s2);
+    QCOMPARE(KWayland::Client::Surface::get(*s1), s1);
+    QCOMPARE(KWayland::Client::Surface::get(*s2), s2);
     serverSurfaceCreated.clear();
     QVERIFY(serverSurfaceCreated.wait());
 
     // delete s2 again
     delete s2;
-    QCOMPARE(KWin::Wayland::Surface::all().count(), 1);
-    QCOMPARE(KWin::Wayland::Surface::all().first(), s1);
-    QCOMPARE(KWin::Wayland::Surface::get(*s1), s1);
+    QCOMPARE(KWayland::Client::Surface::all().count(), 1);
+    QCOMPARE(KWayland::Client::Surface::all().first(), s1);
+    QCOMPARE(KWayland::Client::Surface::get(*s1), s1);
 
     // and finally delete the last one
     delete s1;
-    QVERIFY(KWin::Wayland::Surface::all().isEmpty());
-    QVERIFY(!KWin::Wayland::Surface::get(nullptr));
+    QVERIFY(KWayland::Client::Surface::all().isEmpty());
+    QVERIFY(!KWayland::Client::Surface::get(nullptr));
 }
 
 void TestWaylandSurface::testDamage()
 {
     QSignalSpy serverSurfaceCreated(m_compositorInterface, SIGNAL(surfaceCreated(KWayland::Server::SurfaceInterface*)));
     QVERIFY(serverSurfaceCreated.isValid());
-    KWin::Wayland::Surface *s = m_compositor->createSurface();
+    KWayland::Client::Surface *s = m_compositor->createSurface();
     QVERIFY(serverSurfaceCreated.wait());
     KWayland::Server::SurfaceInterface *serverSurface = serverSurfaceCreated.first().first().value<KWayland::Server::SurfaceInterface*>();
     QVERIFY(serverSurface);
@@ -195,7 +195,7 @@ void TestWaylandSurface::testDamage()
 
     // TODO: actually we would need to attach a buffer first
     s->damage(QRect(0, 0, 10, 10));
-    s->commit(KWin::Wayland::Surface::CommitFlag::None);
+    s->commit(KWayland::Client::Surface::CommitFlag::None);
     QVERIFY(damageSpy.wait());
     QCOMPARE(serverSurface->damage(), QRegion(0, 0, 10, 10));
     QCOMPARE(damageSpy.first().first().value<QRegion>(), QRegion(0, 0, 10, 10));
@@ -205,7 +205,7 @@ void TestWaylandSurface::testDamage()
     testRegion = testRegion.united(QRect(10, 20, 30, 15));
     s->damage(testRegion);
     damageSpy.clear();
-    s->commit(KWin::Wayland::Surface::CommitFlag::None);
+    s->commit(KWayland::Client::Surface::CommitFlag::None);
     QVERIFY(damageSpy.wait());
     QCOMPARE(serverSurface->damage(), testRegion);
     QCOMPARE(damageSpy.first().first().value<QRegion>(), testRegion);
@@ -215,7 +215,7 @@ void TestWaylandSurface::testFrameCallback()
 {
     QSignalSpy serverSurfaceCreated(m_compositorInterface, SIGNAL(surfaceCreated(KWayland::Server::SurfaceInterface*)));
     QVERIFY(serverSurfaceCreated.isValid());
-    KWin::Wayland::Surface *s = m_compositor->createSurface();
+    KWayland::Client::Surface *s = m_compositor->createSurface();
     QVERIFY(serverSurfaceCreated.wait());
     KWayland::Server::SurfaceInterface *serverSurface = serverSurfaceCreated.first().first().value<KWayland::Server::SurfaceInterface*>();
     QVERIFY(serverSurface);
@@ -239,21 +239,21 @@ void TestWaylandSurface::testAttachBuffer()
     // here we need a shm pool
     m_display->createShm();
 
-    KWin::Wayland::Registry registry;
+    KWayland::Client::Registry registry;
     QSignalSpy shmSpy(&registry, SIGNAL(shmAnnounced(quint32,quint32)));
     registry.create(m_connection->display());
     QVERIFY(registry.isValid());
     registry.setup();
     QVERIFY(shmSpy.wait());
 
-    KWin::Wayland::ShmPool pool;
+    KWayland::Client::ShmPool pool;
     pool.setup(registry.bindShm(shmSpy.first().first().value<quint32>(), shmSpy.first().last().value<quint32>()));
     QVERIFY(pool.isValid());
 
     // create the surface
     QSignalSpy serverSurfaceCreated(m_compositorInterface, SIGNAL(surfaceCreated(KWayland::Server::SurfaceInterface*)));
     QVERIFY(serverSurfaceCreated.isValid());
-    KWin::Wayland::Surface *s = m_compositor->createSurface();
+    KWayland::Client::Surface *s = m_compositor->createSurface();
     QVERIFY(serverSurfaceCreated.wait());
     KWayland::Server::SurfaceInterface *serverSurface = serverSurfaceCreated.first().first().value<KWayland::Server::SurfaceInterface*>();
     QVERIFY(serverSurface);
@@ -271,7 +271,7 @@ void TestWaylandSurface::testAttachBuffer()
     s->attachBuffer(redBuffer);
     s->attachBuffer(blackBuffer);
     s->damage(QRect(0, 0, 24, 24));
-    s->commit(KWin::Wayland::Surface::CommitFlag::None);
+    s->commit(KWayland::Client::Surface::CommitFlag::None);
     QSignalSpy damageSpy(serverSurface, SIGNAL(damaged(QRegion)));
     QVERIFY(damageSpy.isValid());
     QVERIFY(damageSpy.wait());
@@ -285,7 +285,7 @@ void TestWaylandSurface::testAttachBuffer()
     // render another frame
     s->attachBuffer(redBuffer);
     s->damage(QRect(0, 0, 24, 24));
-    s->commit(KWin::Wayland::Surface::CommitFlag::None);
+    s->commit(KWayland::Client::Surface::CommitFlag::None);
     damageSpy.clear();
     QVERIFY(damageSpy.wait());
     KWayland::Server::BufferInterface *buffer2 = serverSurface->buffer();