/****************************************************************************
** Meta object code from reading C++ file 'workspace_wrapper.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../scripting/workspace_wrapper.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'workspace_wrapper.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN4KWin16WorkspaceWrapperE_t {};
} // unnamed namespace

template <> constexpr inline auto KWin::WorkspaceWrapper::qt_create_metaobjectdata<qt_meta_tag_ZN4KWin16WorkspaceWrapperE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KWin::WorkspaceWrapper",
        "desktopPresenceChanged",
        "",
        "KWin::Window*",
        "client",
        "desktop",
        "currentDesktopChanged",
        "clientAdded",
        "clientRemoved",
        "clientManaging",
        "KWin::X11Window*",
        "clientMinimized",
        "clientUnminimized",
        "clientRestored",
        "clientMaximizeSet",
        "h",
        "v",
        "killWindowCalled",
        "clientActivated",
        "clientFullScreenSet",
        "fullScreen",
        "user",
        "clientSetKeepAbove",
        "keepAbove",
        "numberDesktopsChanged",
        "oldNumberOfDesktops",
        "desktopLayoutChanged",
        "clientDemandsAttentionChanged",
        "set",
        "numberScreensChanged",
        "count",
        "currentActivityChanged",
        "id",
        "activitiesChanged",
        "activityAdded",
        "activityRemoved",
        "virtualScreenSizeChanged",
        "virtualScreenGeometryChanged",
        "currentVirtualDesktopChanged",
        "cursorPosChanged",
        "slotSwitchDesktopNext",
        "slotSwitchDesktopPrevious",
        "slotSwitchDesktopRight",
        "slotSwitchDesktopLeft",
        "slotSwitchDesktopUp",
        "slotSwitchDesktopDown",
        "slotSwitchToNextScreen",
        "slotSwitchToPrevScreen",
        "slotSwitchToRightScreen",
        "slotSwitchToLeftScreen",
        "slotSwitchToAboveScreen",
        "slotSwitchToBelowScreen",
        "slotWindowToNextScreen",
        "slotWindowToPrevScreen",
        "slotWindowToRightScreen",
        "slotWindowToLeftScreen",
        "slotWindowToAboveScreen",
        "slotWindowToBelowScreen",
        "slotToggleShowDesktop",
        "slotWindowMaximize",
        "slotWindowMaximizeVertical",
        "slotWindowMaximizeHorizontal",
        "slotWindowMinimize",
        "slotWindowShade",
        "slotWindowRaise",
        "slotWindowLower",
        "slotWindowRaiseOrLower",
        "slotActivateAttentionWindow",
        "slotWindowPackLeft",
        "slotWindowPackRight",
        "slotWindowPackUp",
        "slotWindowPackDown",
        "slotWindowGrowHorizontal",
        "slotWindowGrowVertical",
        "slotWindowMoveLeft",
        "slotWindowMoveRight",
        "slotWindowMoveUp",
        "slotWindowMoveDown",
        "slotWindowExpandHorizontal",
        "slotWindowExpandVertical",
        "slotWindowShrinkHorizontal",
        "slotWindowShrinkVertical",
        "slotWindowQuickTileLeft",
        "slotWindowQuickTileRight",
        "slotWindowQuickTileTop",
        "slotWindowQuickTileBottom",
        "slotWindowQuickTileTopLeft",
        "slotWindowQuickTileTopRight",
        "slotWindowQuickTileBottomLeft",
        "slotWindowQuickTileBottomRight",
        "slotSwitchWindowUp",
        "slotSwitchWindowDown",
        "slotSwitchWindowRight",
        "slotSwitchWindowLeft",
        "slotIncreaseWindowOpacity",
        "slotLowerWindowOpacity",
        "slotWindowOperations",
        "slotWindowClose",
        "slotWindowMove",
        "slotWindowResize",
        "slotWindowAbove",
        "slotWindowBelow",
        "slotWindowOnAllDesktops",
        "slotWindowFullScreen",
        "slotWindowNoBorder",
        "slotWindowToNextDesktop",
        "slotWindowToPreviousDesktop",
        "slotWindowToDesktopRight",
        "slotWindowToDesktopLeft",
        "slotWindowToDesktopUp",
        "slotWindowToDesktopDown",
        "sendClientToScreen",
        "screen",
        "showOutline",
        "QRect",
        "geometry",
        "x",
        "y",
        "width",
        "height",
        "hideOutline",
        "setupClientConnections",
        "Window*",
        "screenAt",
        "QPointF",
        "pos",
        "tilingForScreen",
        "KWin::TileManager*",
        "screenName",
        "clientArea",
        "QRectF",
        "ClientAreaOption",
        "option",
        "KWin::Output*",
        "output",
        "KWin::VirtualDesktop*",
        "QPoint",
        "point",
        "const KWin::Window*",
        "desktopName",
        "createDesktop",
        "position",
        "name",
        "removeDesktop",
        "supportInformation",
        "getClient",
        "windowId",
        "updateWindowGeometry",
        "rect",
        "currentDesktop",
        "currentVirtualDesktop",
        "activeClient",
        "desktopGridSize",
        "QSize",
        "desktopGridWidth",
        "desktopGridHeight",
        "workspaceWidth",
        "workspaceHeight",
        "workspaceSize",
        "desktops",
        "displaySize",
        "displayWidth",
        "displayHeight",
        "activeScreen",
        "numScreens",
        "currentActivity",
        "activities",
        "virtualScreenSize",
        "virtualScreenGeometry",
        "cursorPos",
        "PlacementArea",
        "MovementArea",
        "MaximizeArea",
        "MaximizeFullArea",
        "FullScreenArea",
        "WorkArea",
        "FullArea",
        "ScreenArea",
        "ElectricBorder",
        "ElectricTop",
        "ElectricTopRight",
        "ElectricRight",
        "ElectricBottomRight",
        "ElectricBottom",
        "ElectricBottomLeft",
        "ElectricLeft",
        "ElectricTopLeft",
        "ELECTRIC_COUNT",
        "ElectricNone"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'desktopPresenceChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::Int, 5 },
        }}),
        // Signal 'currentDesktopChanged'
        QtMocHelpers::SignalData<void(int, KWin::Window *)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 }, { 0x80000000 | 3, 4 },
        }}),
        // Signal 'clientAdded'
        QtMocHelpers::SignalData<void(KWin::Window *)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'clientRemoved'
        QtMocHelpers::SignalData<void(KWin::Window *)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'clientManaging'
        QtMocHelpers::SignalData<void(KWin::X11Window *)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 4 },
        }}),
        // Signal 'clientMinimized'
        QtMocHelpers::SignalData<void(KWin::Window *)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'clientUnminimized'
        QtMocHelpers::SignalData<void(KWin::Window *)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'clientRestored'
        QtMocHelpers::SignalData<void(KWin::X11Window *)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 4 },
        }}),
        // Signal 'clientMaximizeSet'
        QtMocHelpers::SignalData<void(KWin::Window *, bool, bool)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::Bool, 15 }, { QMetaType::Bool, 16 },
        }}),
        // Signal 'killWindowCalled'
        QtMocHelpers::SignalData<void(KWin::X11Window *)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 4 },
        }}),
        // Signal 'clientActivated'
        QtMocHelpers::SignalData<void(KWin::Window *)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'clientFullScreenSet'
        QtMocHelpers::SignalData<void(KWin::X11Window *, bool, bool)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 4 }, { QMetaType::Bool, 20 }, { QMetaType::Bool, 21 },
        }}),
        // Signal 'clientSetKeepAbove'
        QtMocHelpers::SignalData<void(KWin::X11Window *, bool)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 4 }, { QMetaType::Bool, 23 },
        }}),
        // Signal 'numberDesktopsChanged'
        QtMocHelpers::SignalData<void(uint)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 25 },
        }}),
        // Signal 'desktopLayoutChanged'
        QtMocHelpers::SignalData<void()>(26, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'clientDemandsAttentionChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, bool)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::Bool, 28 },
        }}),
        // Signal 'numberScreensChanged'
        QtMocHelpers::SignalData<void(int)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 30 },
        }}),
        // Signal 'currentActivityChanged'
        QtMocHelpers::SignalData<void(const QString &)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 32 },
        }}),
        // Signal 'activitiesChanged'
        QtMocHelpers::SignalData<void(const QString &)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 32 },
        }}),
        // Signal 'activityAdded'
        QtMocHelpers::SignalData<void(const QString &)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 32 },
        }}),
        // Signal 'activityRemoved'
        QtMocHelpers::SignalData<void(const QString &)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 32 },
        }}),
        // Signal 'virtualScreenSizeChanged'
        QtMocHelpers::SignalData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'virtualScreenGeometryChanged'
        QtMocHelpers::SignalData<void()>(37, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'currentVirtualDesktopChanged'
        QtMocHelpers::SignalData<void()>(38, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'cursorPosChanged'
        QtMocHelpers::SignalData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchDesktopNext'
        QtMocHelpers::SlotData<void()>(40, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchDesktopPrevious'
        QtMocHelpers::SlotData<void()>(41, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchDesktopRight'
        QtMocHelpers::SlotData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchDesktopLeft'
        QtMocHelpers::SlotData<void()>(43, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchDesktopUp'
        QtMocHelpers::SlotData<void()>(44, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchDesktopDown'
        QtMocHelpers::SlotData<void()>(45, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchToNextScreen'
        QtMocHelpers::SlotData<void()>(46, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchToPrevScreen'
        QtMocHelpers::SlotData<void()>(47, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchToRightScreen'
        QtMocHelpers::SlotData<void()>(48, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchToLeftScreen'
        QtMocHelpers::SlotData<void()>(49, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchToAboveScreen'
        QtMocHelpers::SlotData<void()>(50, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchToBelowScreen'
        QtMocHelpers::SlotData<void()>(51, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToNextScreen'
        QtMocHelpers::SlotData<void()>(52, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToPrevScreen'
        QtMocHelpers::SlotData<void()>(53, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToRightScreen'
        QtMocHelpers::SlotData<void()>(54, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToLeftScreen'
        QtMocHelpers::SlotData<void()>(55, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToAboveScreen'
        QtMocHelpers::SlotData<void()>(56, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToBelowScreen'
        QtMocHelpers::SlotData<void()>(57, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotToggleShowDesktop'
        QtMocHelpers::SlotData<void()>(58, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowMaximize'
        QtMocHelpers::SlotData<void()>(59, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowMaximizeVertical'
        QtMocHelpers::SlotData<void()>(60, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowMaximizeHorizontal'
        QtMocHelpers::SlotData<void()>(61, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowMinimize'
        QtMocHelpers::SlotData<void()>(62, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowShade'
        QtMocHelpers::SlotData<void()>(63, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowRaise'
        QtMocHelpers::SlotData<void()>(64, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowLower'
        QtMocHelpers::SlotData<void()>(65, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowRaiseOrLower'
        QtMocHelpers::SlotData<void()>(66, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotActivateAttentionWindow'
        QtMocHelpers::SlotData<void()>(67, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowPackLeft'
        QtMocHelpers::SlotData<void()>(68, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowPackRight'
        QtMocHelpers::SlotData<void()>(69, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowPackUp'
        QtMocHelpers::SlotData<void()>(70, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowPackDown'
        QtMocHelpers::SlotData<void()>(71, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowGrowHorizontal'
        QtMocHelpers::SlotData<void()>(72, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowGrowVertical'
        QtMocHelpers::SlotData<void()>(73, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowMoveLeft'
        QtMocHelpers::SlotData<void()>(74, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowMoveRight'
        QtMocHelpers::SlotData<void()>(75, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowMoveUp'
        QtMocHelpers::SlotData<void()>(76, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowMoveDown'
        QtMocHelpers::SlotData<void()>(77, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowExpandHorizontal'
        QtMocHelpers::SlotData<void()>(78, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowExpandVertical'
        QtMocHelpers::SlotData<void()>(79, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowShrinkHorizontal'
        QtMocHelpers::SlotData<void()>(80, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowShrinkVertical'
        QtMocHelpers::SlotData<void()>(81, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowQuickTileLeft'
        QtMocHelpers::SlotData<void()>(82, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowQuickTileRight'
        QtMocHelpers::SlotData<void()>(83, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowQuickTileTop'
        QtMocHelpers::SlotData<void()>(84, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowQuickTileBottom'
        QtMocHelpers::SlotData<void()>(85, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowQuickTileTopLeft'
        QtMocHelpers::SlotData<void()>(86, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowQuickTileTopRight'
        QtMocHelpers::SlotData<void()>(87, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowQuickTileBottomLeft'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowQuickTileBottomRight'
        QtMocHelpers::SlotData<void()>(89, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchWindowUp'
        QtMocHelpers::SlotData<void()>(90, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchWindowDown'
        QtMocHelpers::SlotData<void()>(91, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchWindowRight'
        QtMocHelpers::SlotData<void()>(92, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchWindowLeft'
        QtMocHelpers::SlotData<void()>(93, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotIncreaseWindowOpacity'
        QtMocHelpers::SlotData<void()>(94, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotLowerWindowOpacity'
        QtMocHelpers::SlotData<void()>(95, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowOperations'
        QtMocHelpers::SlotData<void()>(96, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowClose'
        QtMocHelpers::SlotData<void()>(97, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowMove'
        QtMocHelpers::SlotData<void()>(98, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowResize'
        QtMocHelpers::SlotData<void()>(99, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowAbove'
        QtMocHelpers::SlotData<void()>(100, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowBelow'
        QtMocHelpers::SlotData<void()>(101, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowOnAllDesktops'
        QtMocHelpers::SlotData<void()>(102, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowFullScreen'
        QtMocHelpers::SlotData<void()>(103, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowNoBorder'
        QtMocHelpers::SlotData<void()>(104, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToNextDesktop'
        QtMocHelpers::SlotData<void()>(105, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToPreviousDesktop'
        QtMocHelpers::SlotData<void()>(106, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToDesktopRight'
        QtMocHelpers::SlotData<void()>(107, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToDesktopLeft'
        QtMocHelpers::SlotData<void()>(108, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToDesktopUp'
        QtMocHelpers::SlotData<void()>(109, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotWindowToDesktopDown'
        QtMocHelpers::SlotData<void()>(110, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'sendClientToScreen'
        QtMocHelpers::SlotData<void(KWin::Window *, int)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::Int, 112 },
        }}),
        // Slot 'showOutline'
        QtMocHelpers::SlotData<void(const QRect &)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 114, 115 },
        }}),
        // Slot 'showOutline'
        QtMocHelpers::SlotData<void(int, int, int, int)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 116 }, { QMetaType::Int, 117 }, { QMetaType::Int, 118 }, { QMetaType::Int, 119 },
        }}),
        // Slot 'hideOutline'
        QtMocHelpers::SlotData<void()>(120, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setupClientConnections'
        QtMocHelpers::SlotData<void(Window *)>(121, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 122, 4 },
        }}),
        // Method 'screenAt'
        QtMocHelpers::MethodData<int(const QPointF &) const>(123, 2, QMC::AccessPublic, QMetaType::Int, {{
            { 0x80000000 | 124, 125 },
        }}),
        // Method 'tilingForScreen'
        QtMocHelpers::MethodData<KWin::TileManager *(const QString &) const>(126, 2, QMC::AccessPublic, 0x80000000 | 127, {{
            { QMetaType::QString, 128 },
        }}),
        // Method 'tilingForScreen'
        QtMocHelpers::MethodData<KWin::TileManager *(int) const>(126, 2, QMC::AccessPublic, 0x80000000 | 127, {{
            { QMetaType::Int, 112 },
        }}),
        // Method 'clientArea'
        QtMocHelpers::MethodData<QRectF(enum ClientAreaOption, int, int) const>(129, 2, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 130, {{
            { 0x80000000 | 131, 132 }, { QMetaType::Int, 112 }, { QMetaType::Int, 5 },
        }}),
        // Method 'clientArea'
        QtMocHelpers::MethodData<QRectF(enum ClientAreaOption, KWin::Output *, KWin::VirtualDesktop *) const>(129, 2, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 130, {{
            { 0x80000000 | 131, 132 }, { 0x80000000 | 133, 134 }, { 0x80000000 | 135, 5 },
        }}),
        // Method 'clientArea'
        QtMocHelpers::MethodData<QRectF(enum ClientAreaOption, const QPoint &, int) const>(129, 2, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 130, {{
            { 0x80000000 | 131, 132 }, { 0x80000000 | 136, 137 }, { QMetaType::Int, 5 },
        }}),
        // Method 'clientArea'
        QtMocHelpers::MethodData<QRectF(enum ClientAreaOption, const QPoint &, KWin::VirtualDesktop *) const>(129, 2, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 130, {{
            { 0x80000000 | 131, 132 }, { 0x80000000 | 136, 137 }, { 0x80000000 | 135, 5 },
        }}),
        // Method 'clientArea'
        QtMocHelpers::MethodData<QRectF(enum ClientAreaOption, KWin::Window *) const>(129, 2, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 130, {{
            { 0x80000000 | 131, 132 }, { 0x80000000 | 3, 4 },
        }}),
        // Method 'clientArea'
        QtMocHelpers::MethodData<QRectF(enum ClientAreaOption, const KWin::Window *) const>(129, 2, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 130, {{
            { 0x80000000 | 131, 132 }, { 0x80000000 | 138, 4 },
        }}),
        // Method 'desktopName'
        QtMocHelpers::MethodData<QString(int) const>(139, 2, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString, {{
            { QMetaType::Int, 5 },
        }}),
        // Method 'createDesktop'
        QtMocHelpers::MethodData<void(int, const QString &) const>(140, 2, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 141 }, { QMetaType::QString, 142 },
        }}),
        // Method 'removeDesktop'
        QtMocHelpers::MethodData<void(int) const>(143, 2, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 141 },
        }}),
        // Method 'supportInformation'
        QtMocHelpers::MethodData<QString() const>(144, 2, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString),
        // Method 'getClient'
        QtMocHelpers::MethodData<KWin::X11Window *(qulonglong)>(145, 2, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 10, {{
            { QMetaType::ULongLong, 146 },
        }}),
        // Method 'updateWindowGeometry'
        QtMocHelpers::MethodData<void(KWin::Window *, QRectF)>(147, 2, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { 0x80000000 | 130, 148 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'currentDesktop'
        QtMocHelpers::PropertyData<int>(149, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'currentVirtualDesktop'
        QtMocHelpers::PropertyData<KWin::VirtualDesktop*>(150, 0x80000000 | 135, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 23),
        // property 'activeClient'
        QtMocHelpers::PropertyData<KWin::Window*>(151, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 10),
        // property 'desktopGridSize'
        QtMocHelpers::PropertyData<QSize>(152, 0x80000000 | 153, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 14),
        // property 'desktopGridWidth'
        QtMocHelpers::PropertyData<int>(154, QMetaType::Int, QMC::DefaultPropertyFlags, 14),
        // property 'desktopGridHeight'
        QtMocHelpers::PropertyData<int>(155, QMetaType::Int, QMC::DefaultPropertyFlags, 14),
        // property 'workspaceWidth'
        QtMocHelpers::PropertyData<int>(156, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'workspaceHeight'
        QtMocHelpers::PropertyData<int>(157, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'workspaceSize'
        QtMocHelpers::PropertyData<QSize>(158, 0x80000000 | 153, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'desktops'
        QtMocHelpers::PropertyData<int>(159, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable, 13),
        // property 'displaySize'
        QtMocHelpers::PropertyData<QSize>(160, 0x80000000 | 153, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'displayWidth'
        QtMocHelpers::PropertyData<int>(161, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'displayHeight'
        QtMocHelpers::PropertyData<int>(162, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'activeScreen'
        QtMocHelpers::PropertyData<int>(163, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'numScreens'
        QtMocHelpers::PropertyData<int>(164, QMetaType::Int, QMC::DefaultPropertyFlags, 16),
        // property 'currentActivity'
        QtMocHelpers::PropertyData<QString>(165, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'activities'
        QtMocHelpers::PropertyData<QStringList>(166, QMetaType::QStringList, QMC::DefaultPropertyFlags, 18),
        // property 'virtualScreenSize'
        QtMocHelpers::PropertyData<QSize>(167, 0x80000000 | 153, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 21),
        // property 'virtualScreenGeometry'
        QtMocHelpers::PropertyData<QRect>(168, 0x80000000 | 114, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 22),
        // property 'cursorPos'
        QtMocHelpers::PropertyData<QPoint>(169, 0x80000000 | 136, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 24),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'ClientAreaOption'
        QtMocHelpers::EnumData<enum ClientAreaOption>(131, 131, QMC::EnumFlags{}).add({
            {  170, ClientAreaOption::PlacementArea },
            {  171, ClientAreaOption::MovementArea },
            {  172, ClientAreaOption::MaximizeArea },
            {  173, ClientAreaOption::MaximizeFullArea },
            {  174, ClientAreaOption::FullScreenArea },
            {  175, ClientAreaOption::WorkArea },
            {  176, ClientAreaOption::FullArea },
            {  177, ClientAreaOption::ScreenArea },
        }),
        // enum 'ElectricBorder'
        QtMocHelpers::EnumData<enum ElectricBorder>(178, 178, QMC::EnumFlags{}).add({
            {  179, ElectricBorder::ElectricTop },
            {  180, ElectricBorder::ElectricTopRight },
            {  181, ElectricBorder::ElectricRight },
            {  182, ElectricBorder::ElectricBottomRight },
            {  183, ElectricBorder::ElectricBottom },
            {  184, ElectricBorder::ElectricBottomLeft },
            {  185, ElectricBorder::ElectricLeft },
            {  186, ElectricBorder::ElectricTopLeft },
            {  187, ElectricBorder::ELECTRIC_COUNT },
            {  188, ElectricBorder::ElectricNone },
        }),
    };
    return QtMocHelpers::metaObjectData<WorkspaceWrapper, qt_meta_tag_ZN4KWin16WorkspaceWrapperE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KWin::WorkspaceWrapper::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin16WorkspaceWrapperE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin16WorkspaceWrapperE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4KWin16WorkspaceWrapperE_t>.metaTypes,
    nullptr
} };

void KWin::WorkspaceWrapper::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<WorkspaceWrapper *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->desktopPresenceChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 1: _t->currentDesktopChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[2]))); break;
        case 2: _t->clientAdded((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 3: _t->clientRemoved((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 4: _t->clientManaging((*reinterpret_cast<std::add_pointer_t<KWin::X11Window*>>(_a[1]))); break;
        case 5: _t->clientMinimized((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 6: _t->clientUnminimized((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 7: _t->clientRestored((*reinterpret_cast<std::add_pointer_t<KWin::X11Window*>>(_a[1]))); break;
        case 8: _t->clientMaximizeSet((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 9: _t->killWindowCalled((*reinterpret_cast<std::add_pointer_t<KWin::X11Window*>>(_a[1]))); break;
        case 10: _t->clientActivated((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 11: _t->clientFullScreenSet((*reinterpret_cast<std::add_pointer_t<KWin::X11Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 12: _t->clientSetKeepAbove((*reinterpret_cast<std::add_pointer_t<KWin::X11Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 13: _t->numberDesktopsChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 14: _t->desktopLayoutChanged(); break;
        case 15: _t->clientDemandsAttentionChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 16: _t->numberScreensChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 17: _t->currentActivityChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 18: _t->activitiesChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 19: _t->activityAdded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 20: _t->activityRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 21: _t->virtualScreenSizeChanged(); break;
        case 22: _t->virtualScreenGeometryChanged(); break;
        case 23: _t->currentVirtualDesktopChanged(); break;
        case 24: _t->cursorPosChanged(); break;
        case 25: _t->slotSwitchDesktopNext(); break;
        case 26: _t->slotSwitchDesktopPrevious(); break;
        case 27: _t->slotSwitchDesktopRight(); break;
        case 28: _t->slotSwitchDesktopLeft(); break;
        case 29: _t->slotSwitchDesktopUp(); break;
        case 30: _t->slotSwitchDesktopDown(); break;
        case 31: _t->slotSwitchToNextScreen(); break;
        case 32: _t->slotSwitchToPrevScreen(); break;
        case 33: _t->slotSwitchToRightScreen(); break;
        case 34: _t->slotSwitchToLeftScreen(); break;
        case 35: _t->slotSwitchToAboveScreen(); break;
        case 36: _t->slotSwitchToBelowScreen(); break;
        case 37: _t->slotWindowToNextScreen(); break;
        case 38: _t->slotWindowToPrevScreen(); break;
        case 39: _t->slotWindowToRightScreen(); break;
        case 40: _t->slotWindowToLeftScreen(); break;
        case 41: _t->slotWindowToAboveScreen(); break;
        case 42: _t->slotWindowToBelowScreen(); break;
        case 43: _t->slotToggleShowDesktop(); break;
        case 44: _t->slotWindowMaximize(); break;
        case 45: _t->slotWindowMaximizeVertical(); break;
        case 46: _t->slotWindowMaximizeHorizontal(); break;
        case 47: _t->slotWindowMinimize(); break;
        case 48: _t->slotWindowShade(); break;
        case 49: _t->slotWindowRaise(); break;
        case 50: _t->slotWindowLower(); break;
        case 51: _t->slotWindowRaiseOrLower(); break;
        case 52: _t->slotActivateAttentionWindow(); break;
        case 53: _t->slotWindowPackLeft(); break;
        case 54: _t->slotWindowPackRight(); break;
        case 55: _t->slotWindowPackUp(); break;
        case 56: _t->slotWindowPackDown(); break;
        case 57: _t->slotWindowGrowHorizontal(); break;
        case 58: _t->slotWindowGrowVertical(); break;
        case 59: _t->slotWindowMoveLeft(); break;
        case 60: _t->slotWindowMoveRight(); break;
        case 61: _t->slotWindowMoveUp(); break;
        case 62: _t->slotWindowMoveDown(); break;
        case 63: _t->slotWindowExpandHorizontal(); break;
        case 64: _t->slotWindowExpandVertical(); break;
        case 65: _t->slotWindowShrinkHorizontal(); break;
        case 66: _t->slotWindowShrinkVertical(); break;
        case 67: _t->slotWindowQuickTileLeft(); break;
        case 68: _t->slotWindowQuickTileRight(); break;
        case 69: _t->slotWindowQuickTileTop(); break;
        case 70: _t->slotWindowQuickTileBottom(); break;
        case 71: _t->slotWindowQuickTileTopLeft(); break;
        case 72: _t->slotWindowQuickTileTopRight(); break;
        case 73: _t->slotWindowQuickTileBottomLeft(); break;
        case 74: _t->slotWindowQuickTileBottomRight(); break;
        case 75: _t->slotSwitchWindowUp(); break;
        case 76: _t->slotSwitchWindowDown(); break;
        case 77: _t->slotSwitchWindowRight(); break;
        case 78: _t->slotSwitchWindowLeft(); break;
        case 79: _t->slotIncreaseWindowOpacity(); break;
        case 80: _t->slotLowerWindowOpacity(); break;
        case 81: _t->slotWindowOperations(); break;
        case 82: _t->slotWindowClose(); break;
        case 83: _t->slotWindowMove(); break;
        case 84: _t->slotWindowResize(); break;
        case 85: _t->slotWindowAbove(); break;
        case 86: _t->slotWindowBelow(); break;
        case 87: _t->slotWindowOnAllDesktops(); break;
        case 88: _t->slotWindowFullScreen(); break;
        case 89: _t->slotWindowNoBorder(); break;
        case 90: _t->slotWindowToNextDesktop(); break;
        case 91: _t->slotWindowToPreviousDesktop(); break;
        case 92: _t->slotWindowToDesktopRight(); break;
        case 93: _t->slotWindowToDesktopLeft(); break;
        case 94: _t->slotWindowToDesktopUp(); break;
        case 95: _t->slotWindowToDesktopDown(); break;
        case 96: _t->sendClientToScreen((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 97: _t->showOutline((*reinterpret_cast<std::add_pointer_t<QRect>>(_a[1]))); break;
        case 98: _t->showOutline((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 99: _t->hideOutline(); break;
        case 100: _t->setupClientConnections((*reinterpret_cast<std::add_pointer_t<Window*>>(_a[1]))); break;
        case 101: { int _r = _t->screenAt((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 102: { KWin::TileManager* _r = _t->tilingForScreen((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<KWin::TileManager**>(_a[0]) = std::move(_r); }  break;
        case 103: { KWin::TileManager* _r = _t->tilingForScreen((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<KWin::TileManager**>(_a[0]) = std::move(_r); }  break;
        case 104: { QRectF _r = _t->clientArea((*reinterpret_cast<std::add_pointer_t<enum ClientAreaOption>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QRectF*>(_a[0]) = std::move(_r); }  break;
        case 105: { QRectF _r = _t->clientArea((*reinterpret_cast<std::add_pointer_t<enum ClientAreaOption>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KWin::Output*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<KWin::VirtualDesktop*>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QRectF*>(_a[0]) = std::move(_r); }  break;
        case 106: { QRectF _r = _t->clientArea((*reinterpret_cast<std::add_pointer_t<enum ClientAreaOption>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QRectF*>(_a[0]) = std::move(_r); }  break;
        case 107: { QRectF _r = _t->clientArea((*reinterpret_cast<std::add_pointer_t<enum ClientAreaOption>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<KWin::VirtualDesktop*>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QRectF*>(_a[0]) = std::move(_r); }  break;
        case 108: { QRectF _r = _t->clientArea((*reinterpret_cast<std::add_pointer_t<enum ClientAreaOption>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QRectF*>(_a[0]) = std::move(_r); }  break;
        case 109: { QRectF _r = _t->clientArea((*reinterpret_cast<std::add_pointer_t<enum ClientAreaOption>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<const KWin::Window*>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QRectF*>(_a[0]) = std::move(_r); }  break;
        case 110: { QString _r = _t->desktopName((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 111: _t->createDesktop((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 112: _t->removeDesktop((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 113: { QString _r = _t->supportInformation();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 114: { KWin::X11Window* _r = _t->getClient((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1])));
            if (_a[0]) *reinterpret_cast<KWin::X11Window**>(_a[0]) = std::move(_r); }  break;
        case 115: _t->updateWindowGeometry((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::Window * , int )>(_a, &WorkspaceWrapper::desktopPresenceChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(int , KWin::Window * )>(_a, &WorkspaceWrapper::currentDesktopChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::Window * )>(_a, &WorkspaceWrapper::clientAdded, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::Window * )>(_a, &WorkspaceWrapper::clientRemoved, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::X11Window * )>(_a, &WorkspaceWrapper::clientManaging, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::Window * )>(_a, &WorkspaceWrapper::clientMinimized, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::Window * )>(_a, &WorkspaceWrapper::clientUnminimized, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::X11Window * )>(_a, &WorkspaceWrapper::clientRestored, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::Window * , bool , bool )>(_a, &WorkspaceWrapper::clientMaximizeSet, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::X11Window * )>(_a, &WorkspaceWrapper::killWindowCalled, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::Window * )>(_a, &WorkspaceWrapper::clientActivated, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::X11Window * , bool , bool )>(_a, &WorkspaceWrapper::clientFullScreenSet, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::X11Window * , bool )>(_a, &WorkspaceWrapper::clientSetKeepAbove, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(uint )>(_a, &WorkspaceWrapper::numberDesktopsChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)()>(_a, &WorkspaceWrapper::desktopLayoutChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(KWin::Window * , bool )>(_a, &WorkspaceWrapper::clientDemandsAttentionChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(int )>(_a, &WorkspaceWrapper::numberScreensChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(const QString & )>(_a, &WorkspaceWrapper::currentActivityChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(const QString & )>(_a, &WorkspaceWrapper::activitiesChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(const QString & )>(_a, &WorkspaceWrapper::activityAdded, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)(const QString & )>(_a, &WorkspaceWrapper::activityRemoved, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)()>(_a, &WorkspaceWrapper::virtualScreenSizeChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)()>(_a, &WorkspaceWrapper::virtualScreenGeometryChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)()>(_a, &WorkspaceWrapper::currentVirtualDesktopChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (WorkspaceWrapper::*)()>(_a, &WorkspaceWrapper::cursorPosChanged, 24))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->currentDesktop(); break;
        case 1: *reinterpret_cast<KWin::VirtualDesktop**>(_v) = _t->currentVirtualDesktop(); break;
        case 2: *reinterpret_cast<KWin::Window**>(_v) = _t->activeClient(); break;
        case 3: *reinterpret_cast<QSize*>(_v) = _t->desktopGridSize(); break;
        case 4: *reinterpret_cast<int*>(_v) = _t->desktopGridWidth(); break;
        case 5: *reinterpret_cast<int*>(_v) = _t->desktopGridHeight(); break;
        case 6: *reinterpret_cast<int*>(_v) = _t->workspaceWidth(); break;
        case 7: *reinterpret_cast<int*>(_v) = _t->workspaceHeight(); break;
        case 8: *reinterpret_cast<QSize*>(_v) = _t->workspaceSize(); break;
        case 9: *reinterpret_cast<int*>(_v) = _t->numberOfDesktops(); break;
        case 10: *reinterpret_cast<QSize*>(_v) = _t->displaySize(); break;
        case 11: *reinterpret_cast<int*>(_v) = _t->displayWidth(); break;
        case 12: *reinterpret_cast<int*>(_v) = _t->displayHeight(); break;
        case 13: *reinterpret_cast<int*>(_v) = _t->activeScreen(); break;
        case 14: *reinterpret_cast<int*>(_v) = _t->numScreens(); break;
        case 15: *reinterpret_cast<QString*>(_v) = _t->currentActivity(); break;
        case 16: *reinterpret_cast<QStringList*>(_v) = _t->activityList(); break;
        case 17: *reinterpret_cast<QSize*>(_v) = _t->virtualScreenSize(); break;
        case 18: *reinterpret_cast<QRect*>(_v) = _t->virtualScreenGeometry(); break;
        case 19: *reinterpret_cast<QPoint*>(_v) = _t->cursorPos(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setCurrentDesktop(*reinterpret_cast<int*>(_v)); break;
        case 1: _t->setCurrentVirtualDesktop(*reinterpret_cast<KWin::VirtualDesktop**>(_v)); break;
        case 2: _t->setActiveClient(*reinterpret_cast<KWin::Window**>(_v)); break;
        case 9: _t->setNumberOfDesktops(*reinterpret_cast<int*>(_v)); break;
        case 15: _t->setCurrentActivity(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}

const QMetaObject *KWin::WorkspaceWrapper::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *KWin::WorkspaceWrapper::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin16WorkspaceWrapperE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int KWin::WorkspaceWrapper::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 116)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 116;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 116)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 116;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 20;
    }
    return _id;
}

// SIGNAL 0
void KWin::WorkspaceWrapper::desktopPresenceChanged(KWin::Window * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void KWin::WorkspaceWrapper::currentDesktopChanged(int _t1, KWin::Window * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

// SIGNAL 2
void KWin::WorkspaceWrapper::clientAdded(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void KWin::WorkspaceWrapper::clientRemoved(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void KWin::WorkspaceWrapper::clientManaging(KWin::X11Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void KWin::WorkspaceWrapper::clientMinimized(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void KWin::WorkspaceWrapper::clientUnminimized(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void KWin::WorkspaceWrapper::clientRestored(KWin::X11Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void KWin::WorkspaceWrapper::clientMaximizeSet(KWin::Window * _t1, bool _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1, _t2, _t3);
}

// SIGNAL 9
void KWin::WorkspaceWrapper::killWindowCalled(KWin::X11Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void KWin::WorkspaceWrapper::clientActivated(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void KWin::WorkspaceWrapper::clientFullScreenSet(KWin::X11Window * _t1, bool _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2, _t3);
}

// SIGNAL 12
void KWin::WorkspaceWrapper::clientSetKeepAbove(KWin::X11Window * _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2);
}

// SIGNAL 13
void KWin::WorkspaceWrapper::numberDesktopsChanged(uint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void KWin::WorkspaceWrapper::desktopLayoutChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void KWin::WorkspaceWrapper::clientDemandsAttentionChanged(KWin::Window * _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1, _t2);
}

// SIGNAL 16
void KWin::WorkspaceWrapper::numberScreensChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void KWin::WorkspaceWrapper::currentActivityChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void KWin::WorkspaceWrapper::activitiesChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void KWin::WorkspaceWrapper::activityAdded(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void KWin::WorkspaceWrapper::activityRemoved(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void KWin::WorkspaceWrapper::virtualScreenSizeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void KWin::WorkspaceWrapper::virtualScreenGeometryChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void KWin::WorkspaceWrapper::currentVirtualDesktopChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 23, nullptr);
}

// SIGNAL 24
void KWin::WorkspaceWrapper::cursorPosChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}
namespace {
struct qt_meta_tag_ZN4KWin24QtScriptWorkspaceWrapperE_t {};
} // unnamed namespace

template <> constexpr inline auto KWin::QtScriptWorkspaceWrapper::qt_create_metaobjectdata<qt_meta_tag_ZN4KWin24QtScriptWorkspaceWrapperE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KWin::QtScriptWorkspaceWrapper",
        "clientList",
        "QList<KWin::Window*>",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'clientList'
        QtMocHelpers::MethodData<QList<KWin::Window*>() const>(1, 3, QMC::AccessPublic, 0x80000000 | 2),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QtScriptWorkspaceWrapper, qt_meta_tag_ZN4KWin24QtScriptWorkspaceWrapperE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KWin::QtScriptWorkspaceWrapper::staticMetaObject = { {
    QMetaObject::SuperData::link<WorkspaceWrapper::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin24QtScriptWorkspaceWrapperE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin24QtScriptWorkspaceWrapperE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4KWin24QtScriptWorkspaceWrapperE_t>.metaTypes,
    nullptr
} };

void KWin::QtScriptWorkspaceWrapper::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QtScriptWorkspaceWrapper *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QList<KWin::Window*> _r = _t->clientList();
            if (_a[0]) *reinterpret_cast<QList<KWin::Window*>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

const QMetaObject *KWin::QtScriptWorkspaceWrapper::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *KWin::QtScriptWorkspaceWrapper::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin24QtScriptWorkspaceWrapperE_t>.strings))
        return static_cast<void*>(this);
    return WorkspaceWrapper::qt_metacast(_clname);
}

int KWin::QtScriptWorkspaceWrapper::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = WorkspaceWrapper::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN4KWin33DeclarativeScriptWorkspaceWrapperE_t {};
} // unnamed namespace

template <> constexpr inline auto KWin::DeclarativeScriptWorkspaceWrapper::qt_create_metaobjectdata<qt_meta_tag_ZN4KWin33DeclarativeScriptWorkspaceWrapperE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KWin::DeclarativeScriptWorkspaceWrapper",
        "clients",
        "QQmlListProperty<KWin::Window>"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'clients'
        QtMocHelpers::PropertyData<QQmlListProperty<KWin::Window>>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DeclarativeScriptWorkspaceWrapper, qt_meta_tag_ZN4KWin33DeclarativeScriptWorkspaceWrapperE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KWin::DeclarativeScriptWorkspaceWrapper::staticMetaObject = { {
    QMetaObject::SuperData::link<WorkspaceWrapper::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin33DeclarativeScriptWorkspaceWrapperE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin33DeclarativeScriptWorkspaceWrapperE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4KWin33DeclarativeScriptWorkspaceWrapperE_t>.metaTypes,
    nullptr
} };

void KWin::DeclarativeScriptWorkspaceWrapper::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DeclarativeScriptWorkspaceWrapper *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QQmlListProperty<KWin::Window>*>(_v) = _t->clients(); break;
        default: break;
        }
    }
}

const QMetaObject *KWin::DeclarativeScriptWorkspaceWrapper::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *KWin::DeclarativeScriptWorkspaceWrapper::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin33DeclarativeScriptWorkspaceWrapperE_t>.strings))
        return static_cast<void*>(this);
    return WorkspaceWrapper::qt_metacast(_clname);
}

int KWin::DeclarativeScriptWorkspaceWrapper::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = WorkspaceWrapper::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
QT_WARNING_POP
