#ifndef REP_TREELAND_WINDOWTREE_REPLICA_H
#define REP_TREELAND_WINDOWTREE_REPLICA_H

// This is an autogenerated file.
// Do not edit this file, any changes made will be lost the next time it is generated.

#include <QtCore/qobject.h>
#include <QtCore/qdatastream.h>
#include <QtCore/qvariant.h>
#include <QtCore/qmap.h>
#include <QtCore/qmetatype.h>

#include <QtRemoteObjects/qremoteobjectnode.h>
#include <QtRemoteObjects/qremoteobjectpendingcall.h>
#include <QtRemoteObjects/qremoteobjectreplica.h>

#include <QtCore/QVariant>

#include <QtCore/QRectF>

#include <QtCore/QPointF>

using namespace Qt::Literals::StringLiterals;

class WindowInfo
{
    Q_GADGET

    Q_PROPERTY(qint64 id READ id WRITE setId)
    Q_PROPERTY(QString appId READ appId WRITE setAppId)
    Q_PROPERTY(QString title READ title WRITE setTitle)
    Q_PROPERTY(QString output READ output WRITE setOutput)
    Q_PROPERTY(QString container READ container WRITE setContainer)
    Q_PROPERTY(int workspace READ workspace WRITE setWorkspace)
    Q_PROPERTY(int layer READ layer WRITE setLayer)
    Q_PROPERTY(int z READ z WRITE setZ)
    Q_PROPERTY(int type READ type WRITE setType)
    Q_PROPERTY(int state READ state WRITE setState)
    Q_PROPERTY(bool visible READ visible WRITE setVisible)
    Q_PROPERTY(bool active READ active WRITE setActive)
    Q_PROPERTY(QRectF geometry READ geometry WRITE setGeometry)
    Q_PROPERTY(QRectF titlebarGeometry READ titlebarGeometry WRITE setTitlebarGeometry)
    Q_PROPERTY(QRectF boundingRect READ boundingRect WRITE setBoundingRect)
    Q_PROPERTY(QRectF iconGeometry READ iconGeometry WRITE setIconGeometry)
    Q_PROPERTY(QPointF position READ position WRITE setPosition)
    Q_PROPERTY(qint64 frames READ frames WRITE setFrames)
    Q_PROPERTY(QRectF damage READ damage WRITE setDamage)
public:
    WindowInfo() : m_id(), m_appId(), m_title(), m_output(), m_container(), m_workspace(), m_layer(), m_z(), m_type(), m_state(), m_visible(), m_active(), m_geometry(), m_titlebarGeometry(), m_boundingRect(), m_iconGeometry(), m_position(), m_frames(), m_damage() {}
    explicit WindowInfo(qint64 id, QString appId, QString title, QString output, QString container, int workspace, int layer, int z, int type, int state, bool visible, bool active, QRectF geometry, QRectF titlebarGeometry, QRectF boundingRect, QRectF iconGeometry, QPointF position, qint64 frames, QRectF damage) : m_id(id), m_appId(appId), m_title(title), m_output(output), m_container(container), m_workspace(workspace), m_layer(layer), m_z(z), m_type(type), m_state(state), m_visible(visible), m_active(active), m_geometry(geometry), m_titlebarGeometry(titlebarGeometry), m_boundingRect(boundingRect), m_iconGeometry(iconGeometry), m_position(position), m_frames(frames), m_damage(damage) {}
    qint64 id() const { return m_id; }
    void setId(qint64 id) { if (id != m_id) { m_id = id; } }
    QString appId() const { return m_appId; }
    void setAppId(QString appId) { if (appId != m_appId) { m_appId = appId; } }
    QString title() const { return m_title; }
    void setTitle(QString title) { if (title != m_title) { m_title = title; } }
    QString output() const { return m_output; }
    void setOutput(QString output) { if (output != m_output) { m_output = output; } }
    QString container() const { return m_container; }
    void setContainer(QString container) { if (container != m_container) { m_container = container; } }
    int workspace() const { return m_workspace; }
    void setWorkspace(int workspace) { if (workspace != m_workspace) { m_workspace = workspace; } }
    int layer() const { return m_layer; }
    void setLayer(int layer) { if (layer != m_layer) { m_layer = layer; } }
    int z() const { return m_z; }
    void setZ(int z) { if (z != m_z) { m_z = z; } }
    int type() const { return m_type; }
    void setType(int type) { if (type != m_type) { m_type = type; } }
    int state() const { return m_state; }
    void setState(int state) { if (state != m_state) { m_state = state; } }
    bool visible() const { return m_visible; }
    void setVisible(bool visible) { if (visible != m_visible) { m_visible = visible; } }
    bool active() const { return m_active; }
    void setActive(bool active) { if (active != m_active) { m_active = active; } }
    QRectF geometry() const { return m_geometry; }
    void setGeometry(QRectF geometry) { if (geometry != m_geometry) { m_geometry = geometry; } }
    QRectF titlebarGeometry() const { return m_titlebarGeometry; }
    void setTitlebarGeometry(QRectF titlebarGeometry) { if (titlebarGeometry != m_titlebarGeometry) { m_titlebarGeometry = titlebarGeometry; } }
    QRectF boundingRect() const { return m_boundingRect; }
    void setBoundingRect(QRectF boundingRect) { if (boundingRect != m_boundingRect) { m_boundingRect = boundingRect; } }
    QRectF iconGeometry() const { return m_iconGeometry; }
    void setIconGeometry(QRectF iconGeometry) { if (iconGeometry != m_iconGeometry) { m_iconGeometry = iconGeometry; } }
    QPointF position() const { return m_position; }
    void setPosition(QPointF position) { if (position != m_position) { m_position = position; } }
    qint64 frames() const { return m_frames; }
    void setFrames(qint64 frames) { if (frames != m_frames) { m_frames = frames; } }
    QRectF damage() const { return m_damage; }
    void setDamage(QRectF damage) { if (damage != m_damage) { m_damage = damage; } }
private:
    qint64 m_id;
    QString m_appId;
    QString m_title;
    QString m_output;
    QString m_container;
    int m_workspace;
    int m_layer;
    int m_z;
    int m_type;
    int m_state;
    bool m_visible;
    bool m_active;
    QRectF m_geometry;
    QRectF m_titlebarGeometry;
    QRectF m_boundingRect;
    QRectF m_iconGeometry;
    QPointF m_position;
    qint64 m_frames;
    QRectF m_damage;
};

inline bool operator==(const WindowInfo &left, const WindowInfo &right) Q_DECL_NOTHROW {
    return left.id() == right.id() && left.appId() == right.appId() && left.title() == right.title() && left.output() == right.output() && left.container() == right.container() && left.workspace() == right.workspace() && left.layer() == right.layer() && left.z() == right.z() && left.type() == right.type() && left.state() == right.state() && left.visible() == right.visible() && left.active() == right.active() && left.geometry() == right.geometry() && left.titlebarGeometry() == right.titlebarGeometry() && left.boundingRect() == right.boundingRect() && left.iconGeometry() == right.iconGeometry() && left.position() == right.position() && left.frames() == right.frames() && left.damage() == right.damage();
}
inline bool operator!=(const WindowInfo &left, const WindowInfo &right) Q_DECL_NOTHROW {
    return !(left == right);
}

inline QDebug operator<<(QDebug dbg, const WindowInfo &obj) {
    dbg.nospace() << "WindowInfo("  << "id: " << obj.id() << ", " << "appId: " << obj.appId() << ", " << "title: " << obj.title() << ", " << "output: " << obj.output() << ", " << "container: " << obj.container() << ", " << "workspace: " << obj.workspace() << ", " << "layer: " << obj.layer() << ", " << "z: " << obj.z() << ", " << "type: " << obj.type() << ", " << "state: " << obj.state() << ", " << "visible: " << obj.visible() << ", " << "active: " << obj.active() << ", " << "geometry: " << obj.geometry() << ", " << "titlebarGeometry: " << obj.titlebarGeometry() << ", " << "boundingRect: " << obj.boundingRect() << ", " << "iconGeometry: " << obj.iconGeometry() << ", " << "position: " << obj.position() << ", " << "frames: " << obj.frames() << ", " << "damage: " << obj.damage() << ")";
    return dbg.maybeSpace();
}

inline QDataStream &operator<<(QDataStream &ds, const WindowInfo &obj) {
    QtRemoteObjects::copyStoredProperties(&obj, ds);
    return ds;
}

inline QDataStream &operator>>(QDataStream &ds, WindowInfo &obj) {
    QtRemoteObjects::copyStoredProperties(ds, &obj);
    return ds;
}

class WorkspaceInfo
{
    Q_GADGET

    Q_PROPERTY(int id READ id WRITE setId)
    Q_PROPERTY(bool isActive READ isActive WRITE setIsActive)
    Q_PROPERTY(QList<WindowInfo> windows READ windows WRITE setWindows)
public:
    WorkspaceInfo() : m_id(), m_isActive(), m_windows() {}
    explicit WorkspaceInfo(int id, bool isActive, QList<WindowInfo> windows) : m_id(id), m_isActive(isActive), m_windows(windows) {}
    int id() const { return m_id; }
    void setId(int id) { if (id != m_id) { m_id = id; } }
    bool isActive() const { return m_isActive; }
    void setIsActive(bool isActive) { if (isActive != m_isActive) { m_isActive = isActive; } }
    QList<WindowInfo> windows() const { return m_windows; }
    void setWindows(QList<WindowInfo> windows) { if (windows != m_windows) { m_windows = windows; } }
private:
    int m_id;
    bool m_isActive;
    QList<WindowInfo> m_windows;
};

inline bool operator==(const WorkspaceInfo &left, const WorkspaceInfo &right) Q_DECL_NOTHROW {
    return left.id() == right.id() && left.isActive() == right.isActive() && left.windows() == right.windows();
}
inline bool operator!=(const WorkspaceInfo &left, const WorkspaceInfo &right) Q_DECL_NOTHROW {
    return !(left == right);
}

inline QDebug operator<<(QDebug dbg, const WorkspaceInfo &obj) {
    dbg.nospace() << "WorkspaceInfo("  << "id: " << obj.id() << ", " << "isActive: " << obj.isActive() << ", " << "windows: " << obj.windows() << ")";
    return dbg.maybeSpace();
}

inline QDataStream &operator<<(QDataStream &ds, const WorkspaceInfo &obj) {
    QtRemoteObjects::copyStoredProperties(&obj, ds);
    return ds;
}

inline QDataStream &operator>>(QDataStream &ds, WorkspaceInfo &obj) {
    QtRemoteObjects::copyStoredProperties(ds, &obj);
    return ds;
}

class LayerInfo
{
    Q_GADGET

    Q_PROPERTY(QString name READ name WRITE setName)
    Q_PROPERTY(int layer READ layer WRITE setLayer)
    Q_PROPERTY(QList<WindowInfo> windows READ windows WRITE setWindows)
    Q_PROPERTY(QList<WorkspaceInfo> workspaces READ workspaces WRITE setWorkspaces)
public:
    LayerInfo() : m_name(), m_layer(), m_windows(), m_workspaces() {}
    explicit LayerInfo(QString name, int layer, QList<WindowInfo> windows, QList<WorkspaceInfo> workspaces) : m_name(name), m_layer(layer), m_windows(windows), m_workspaces(workspaces) {}
    QString name() const { return m_name; }
    void setName(QString name) { if (name != m_name) { m_name = name; } }
    int layer() const { return m_layer; }
    void setLayer(int layer) { if (layer != m_layer) { m_layer = layer; } }
    QList<WindowInfo> windows() const { return m_windows; }
    void setWindows(QList<WindowInfo> windows) { if (windows != m_windows) { m_windows = windows; } }
    QList<WorkspaceInfo> workspaces() const { return m_workspaces; }
    void setWorkspaces(QList<WorkspaceInfo> workspaces) { if (workspaces != m_workspaces) { m_workspaces = workspaces; } }
private:
    QString m_name;
    int m_layer;
    QList<WindowInfo> m_windows;
    QList<WorkspaceInfo> m_workspaces;
};

inline bool operator==(const LayerInfo &left, const LayerInfo &right) Q_DECL_NOTHROW {
    return left.name() == right.name() && left.layer() == right.layer() && left.windows() == right.windows() && left.workspaces() == right.workspaces();
}
inline bool operator!=(const LayerInfo &left, const LayerInfo &right) Q_DECL_NOTHROW {
    return !(left == right);
}

inline QDebug operator<<(QDebug dbg, const LayerInfo &obj) {
    dbg.nospace() << "LayerInfo("  << "name: " << obj.name() << ", " << "layer: " << obj.layer() << ", " << "windows: " << obj.windows() << ", " << "workspaces: " << obj.workspaces() << ")";
    return dbg.maybeSpace();
}

inline QDataStream &operator<<(QDataStream &ds, const LayerInfo &obj) {
    QtRemoteObjects::copyStoredProperties(&obj, ds);
    return ds;
}

inline QDataStream &operator>>(QDataStream &ds, LayerInfo &obj) {
    QtRemoteObjects::copyStoredProperties(ds, &obj);
    return ds;
}

class TreelandInfo
{
    Q_GADGET

    Q_PROPERTY(QString currentMode READ currentMode WRITE setCurrentMode)
    Q_PROPERTY(QList<LayerInfo> layers READ layers WRITE setLayers)
public:
    TreelandInfo() : m_currentMode(), m_layers() {}
    explicit TreelandInfo(QString currentMode, QList<LayerInfo> layers) : m_currentMode(currentMode), m_layers(layers) {}
    QString currentMode() const { return m_currentMode; }
    void setCurrentMode(QString currentMode) { if (currentMode != m_currentMode) { m_currentMode = currentMode; } }
    QList<LayerInfo> layers() const { return m_layers; }
    void setLayers(QList<LayerInfo> layers) { if (layers != m_layers) { m_layers = layers; } }
private:
    QString m_currentMode;
    QList<LayerInfo> m_layers;
};

inline bool operator==(const TreelandInfo &left, const TreelandInfo &right) Q_DECL_NOTHROW {
    return left.currentMode() == right.currentMode() && left.layers() == right.layers();
}
inline bool operator!=(const TreelandInfo &left, const TreelandInfo &right) Q_DECL_NOTHROW {
    return !(left == right);
}

inline QDebug operator<<(QDebug dbg, const TreelandInfo &obj) {
    dbg.nospace() << "TreelandInfo("  << "currentMode: " << obj.currentMode() << ", " << "layers: " << obj.layers() << ")";
    return dbg.maybeSpace();
}

inline QDataStream &operator<<(QDataStream &ds, const TreelandInfo &obj) {
    QtRemoteObjects::copyStoredProperties(&obj, ds);
    return ds;
}

inline QDataStream &operator>>(QDataStream &ds, TreelandInfo &obj) {
    QtRemoteObjects::copyStoredProperties(ds, &obj);
    return ds;
}

class ClientInfo
{
    Q_GADGET

    Q_PROPERTY(qint64 id READ id WRITE setId)
    Q_PROPERTY(QString appId READ appId WRITE setAppId)
    Q_PROPERTY(int pid READ pid WRITE setPid)
    Q_PROPERTY(QString executable READ executable WRITE setExecutable)
    Q_PROPERTY(QString command READ command WRITE setCommand)
    Q_PROPERTY(QList<WindowInfo> windows READ windows WRITE setWindows)
public:
    ClientInfo() : m_id(), m_appId(), m_pid(), m_executable(), m_command(), m_windows() {}
    explicit ClientInfo(qint64 id, QString appId, int pid, QString executable, QString command, QList<WindowInfo> windows) : m_id(id), m_appId(appId), m_pid(pid), m_executable(executable), m_command(command), m_windows(windows) {}
    qint64 id() const { return m_id; }
    void setId(qint64 id) { if (id != m_id) { m_id = id; } }
    QString appId() const { return m_appId; }
    void setAppId(QString appId) { if (appId != m_appId) { m_appId = appId; } }
    int pid() const { return m_pid; }
    void setPid(int pid) { if (pid != m_pid) { m_pid = pid; } }
    QString executable() const { return m_executable; }
    void setExecutable(QString executable) { if (executable != m_executable) { m_executable = executable; } }
    QString command() const { return m_command; }
    void setCommand(QString command) { if (command != m_command) { m_command = command; } }
    QList<WindowInfo> windows() const { return m_windows; }
    void setWindows(QList<WindowInfo> windows) { if (windows != m_windows) { m_windows = windows; } }
private:
    qint64 m_id;
    QString m_appId;
    int m_pid;
    QString m_executable;
    QString m_command;
    QList<WindowInfo> m_windows;
};

inline bool operator==(const ClientInfo &left, const ClientInfo &right) Q_DECL_NOTHROW {
    return left.id() == right.id() && left.appId() == right.appId() && left.pid() == right.pid() && left.executable() == right.executable() && left.command() == right.command() && left.windows() == right.windows();
}
inline bool operator!=(const ClientInfo &left, const ClientInfo &right) Q_DECL_NOTHROW {
    return !(left == right);
}

inline QDebug operator<<(QDebug dbg, const ClientInfo &obj) {
    dbg.nospace() << "ClientInfo("  << "id: " << obj.id() << ", " << "appId: " << obj.appId() << ", " << "pid: " << obj.pid() << ", " << "executable: " << obj.executable() << ", " << "command: " << obj.command() << ", " << "windows: " << obj.windows() << ")";
    return dbg.maybeSpace();
}

inline QDataStream &operator<<(QDataStream &ds, const ClientInfo &obj) {
    QtRemoteObjects::copyStoredProperties(&obj, ds);
    return ds;
}

inline QDataStream &operator>>(QDataStream &ds, ClientInfo &obj) {
    QtRemoteObjects::copyStoredProperties(ds, &obj);
    return ds;
}

class DebugEvent
{
    Q_GADGET

    Q_PROPERTY(quint64 seq READ seq WRITE setSeq)
    Q_PROPERTY(int type READ type WRITE setType)
    Q_PROPERTY(qint64 target READ target WRITE setTarget)
    Q_PROPERTY(QString detail READ detail WRITE setDetail)
    Q_PROPERTY(quint64 timestampMs READ timestampMs WRITE setTimestampMs)
public:
    DebugEvent() : m_seq(), m_type(), m_target(), m_detail(), m_timestampMs() {}
    explicit DebugEvent(quint64 seq, int type, qint64 target, QString detail, quint64 timestampMs) : m_seq(seq), m_type(type), m_target(target), m_detail(detail), m_timestampMs(timestampMs) {}
    quint64 seq() const { return m_seq; }
    void setSeq(quint64 seq) { if (seq != m_seq) { m_seq = seq; } }
    int type() const { return m_type; }
    void setType(int type) { if (type != m_type) { m_type = type; } }
    qint64 target() const { return m_target; }
    void setTarget(qint64 target) { if (target != m_target) { m_target = target; } }
    QString detail() const { return m_detail; }
    void setDetail(QString detail) { if (detail != m_detail) { m_detail = detail; } }
    quint64 timestampMs() const { return m_timestampMs; }
    void setTimestampMs(quint64 timestampMs) { if (timestampMs != m_timestampMs) { m_timestampMs = timestampMs; } }
private:
    quint64 m_seq;
    int m_type;
    qint64 m_target;
    QString m_detail;
    quint64 m_timestampMs;
};

inline bool operator==(const DebugEvent &left, const DebugEvent &right) Q_DECL_NOTHROW {
    return left.seq() == right.seq() && left.type() == right.type() && left.target() == right.target() && left.detail() == right.detail() && left.timestampMs() == right.timestampMs();
}
inline bool operator!=(const DebugEvent &left, const DebugEvent &right) Q_DECL_NOTHROW {
    return !(left == right);
}

inline QDebug operator<<(QDebug dbg, const DebugEvent &obj) {
    dbg.nospace() << "DebugEvent("  << "seq: " << obj.seq() << ", " << "type: " << obj.type() << ", " << "target: " << obj.target() << ", " << "detail: " << obj.detail() << ", " << "timestampMs: " << obj.timestampMs() << ")";
    return dbg.maybeSpace();
}

inline QDataStream &operator<<(QDataStream &ds, const DebugEvent &obj) {
    QtRemoteObjects::copyStoredProperties(&obj, ds);
    return ds;
}

inline QDataStream &operator>>(QDataStream &ds, DebugEvent &obj) {
    QtRemoteObjects::copyStoredProperties(ds, &obj);
    return ds;
}

class WindowTreeRemoteReplica : public QRemoteObjectReplica
{
    Q_OBJECT
    Q_CLASSINFO(QCLASSINFO_REMOTEOBJECT_TYPE, "WindowTreeRemote")
    Q_CLASSINFO(QCLASSINFO_REMOTEOBJECT_SIGNATURE, "a78bdcbbcab9e86be485cf71c02363a6a492a249")
    Q_PROPERTY(QPointF cursorPosition READ cursorPosition NOTIFY cursorPositionChanged)

public:
    WindowTreeRemoteReplica() : QRemoteObjectReplica() { initialize(); }
    static void registerMetatypes()
    {
        static bool initialized = false;
        if (initialized)
            return;
        initialized = true;
        qRegisterMetaType<qint64>();
        qRegisterMetaType<WindowInfo>();
        qRegisterMetaType<WorkspaceInfo>();
        qRegisterMetaType<TreelandInfo>();
        qRegisterMetaType<QList<LayerInfo>>();
        qRegisterMetaType<QList<WorkspaceInfo>>();
        qRegisterMetaType<QList<WindowInfo>>();
        qRegisterMetaType<quint64>();
        qRegisterMetaType<LayerInfo>();
        qRegisterMetaType<DebugEvent>();
        qRegisterMetaType<ClientInfo>();
        qRegisterMetaType<qint64>();
        qRegisterMetaType<TreelandInfo>();
        qRegisterMetaType<QList<WindowInfo>>();
        qRegisterMetaType<QList<DebugEvent>>();
        qRegisterMetaType<QList<ClientInfo>>();
        qRegisterMetaType<quint64>();
        qRegisterMetaType<QRemoteObjectPendingCall>();
        qRegisterMetaType<QRemoteObjectPendingReply<qint64>>();
        if (!QMetaType::hasRegisteredConverterFunction<QRemoteObjectPendingReply<qint64>, QRemoteObjectPendingCall>())
            QMetaType::registerConverter<QRemoteObjectPendingReply<qint64>, QRemoteObjectPendingCall>();
        qRegisterMetaType<QRemoteObjectPendingReply<QString>>();
        if (!QMetaType::hasRegisteredConverterFunction<QRemoteObjectPendingReply<QString>, QRemoteObjectPendingCall>())
            QMetaType::registerConverter<QRemoteObjectPendingReply<QString>, QRemoteObjectPendingCall>();
        qRegisterMetaType<QRemoteObjectPendingReply<TreelandInfo>>();
        if (!QMetaType::hasRegisteredConverterFunction<QRemoteObjectPendingReply<TreelandInfo>, QRemoteObjectPendingCall>())
            QMetaType::registerConverter<QRemoteObjectPendingReply<TreelandInfo>, QRemoteObjectPendingCall>();
        qRegisterMetaType<QRemoteObjectPendingReply<void>>();
        if (!QMetaType::hasRegisteredConverterFunction<QRemoteObjectPendingReply<void>, QRemoteObjectPendingCall>())
            QMetaType::registerConverter<QRemoteObjectPendingReply<void>, QRemoteObjectPendingCall>();
        qRegisterMetaType<QRemoteObjectPendingReply<QList<WindowInfo>>>();
        if (!QMetaType::hasRegisteredConverterFunction<QRemoteObjectPendingReply<QList<WindowInfo>>, QRemoteObjectPendingCall>())
            QMetaType::registerConverter<QRemoteObjectPendingReply<QList<WindowInfo>>, QRemoteObjectPendingCall>();
        qRegisterMetaType<QRemoteObjectPendingReply<QList<DebugEvent>>>();
        if (!QMetaType::hasRegisteredConverterFunction<QRemoteObjectPendingReply<QList<DebugEvent>>, QRemoteObjectPendingCall>())
            QMetaType::registerConverter<QRemoteObjectPendingReply<QList<DebugEvent>>, QRemoteObjectPendingCall>();
        qRegisterMetaType<QRemoteObjectPendingReply<QList<ClientInfo>>>();
        if (!QMetaType::hasRegisteredConverterFunction<QRemoteObjectPendingReply<QList<ClientInfo>>, QRemoteObjectPendingCall>())
            QMetaType::registerConverter<QRemoteObjectPendingReply<QList<ClientInfo>>, QRemoteObjectPendingCall>();
        qRegisterMetaType<QRemoteObjectPendingReply<bool>>();
        if (!QMetaType::hasRegisteredConverterFunction<QRemoteObjectPendingReply<bool>, QRemoteObjectPendingCall>())
            QMetaType::registerConverter<QRemoteObjectPendingReply<bool>, QRemoteObjectPendingCall>();

    }

private:
    WindowTreeRemoteReplica(QRemoteObjectNode *node, const QString &name = QString())
        : QRemoteObjectReplica(ConstructWithNode)
    {
        initializeNode(node, name);
    }

    void initialize() override
    {
        WindowTreeRemoteReplica::registerMetatypes();
        QVariantList properties;
        properties.reserve(1);
        properties << QVariant::fromValue(QPointF());
        setProperties(std::move(properties));
    }

public:
    ~WindowTreeRemoteReplica() override = default;

    QPointF cursorPosition() const
    {
        const QVariant variant = propAsVariant(0);
        if (!variant.canConvert<QPointF>()) {
            qWarning() << "QtRO cannot convert the property cursorPosition to type QPointF";
        }
        return variant.value<QPointF >();
    }


Q_SIGNALS:
    void cursorPositionChanged(QPointF cursorPosition);
    void captureResult(QByteArray data);

public Q_SLOTS:
    QRemoteObjectPendingReply<TreelandInfo> getTreelandInfo()
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("getTreelandInfo()");
        QVariantList __repc_args;
        return QRemoteObjectPendingReply<TreelandInfo>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<QList<WindowInfo>> getWindows()
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("getWindows()");
        QVariantList __repc_args;
        return QRemoteObjectPendingReply<QList<WindowInfo>>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<QList<ClientInfo>> getClients()
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("getClients()");
        QVariantList __repc_args;
        return QRemoteObjectPendingReply<QList<ClientInfo>>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> activateWindow(qint64 id)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("activateWindow(qint64)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(id)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> closeWindow(qint64 id)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("closeWindow(qint64)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(id)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> minimizeWindow(qint64 id)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("minimizeWindow(qint64)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(id)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> toggleMaximized(qint64 id)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("toggleMaximized(qint64)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(id)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> toggleFullscreen(qint64 id)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("toggleFullscreen(qint64)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(id)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> moveWindow(qint64 id, int x, int y)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("moveWindow(qint64,int,int)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(id)
            << QVariant::fromValue(x)
            << QVariant::fromValue(y)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> resizeWindow(qint64 id, int w, int h)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("resizeWindow(qint64,int,int)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(id)
            << QVariant::fromValue(w)
            << QVariant::fromValue(h)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> setWindowWorkspace(qint64 id, int workspaceId)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("setWindowWorkspace(qint64,int)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(id)
            << QVariant::fromValue(workspaceId)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> moveCursor(QPointF pos)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("moveCursor(QPointF)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(pos)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> sendPointerButton(int button, bool pressed)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("sendPointerButton(int,bool)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(button)
            << QVariant::fromValue(pressed)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<bool> sendKey(int qtKey, bool pressed)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("sendKey(int,bool)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(qtKey)
            << QVariant::fromValue(pressed)
        ;
        return QRemoteObjectPendingReply<bool>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    void captureOutput(QString outputName)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("captureOutput(QString)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(outputName)
        ;
        send(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args);
    }
    void captureWindow(qint64 id)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("captureWindow(qint64)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(id)
        ;
        send(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args);
    }
    QRemoteObjectPendingReply<QList<DebugEvent>> getEvents(quint64 afterSeq)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("getEvents(quint64)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(afterSeq)
        ;
        return QRemoteObjectPendingReply<QList<DebugEvent>>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<qint64> focusedWindowId()
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("focusedWindowId()");
        QVariantList __repc_args;
        return QRemoteObjectPendingReply<qint64>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<qint64> windowUnderCursor()
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("windowUnderCursor()");
        QVariantList __repc_args;
        return QRemoteObjectPendingReply<qint64>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }
    QRemoteObjectPendingReply<QString> getSceneTree(qint64 id)
    {
        static int __repc_index = WindowTreeRemoteReplica::staticMetaObject.indexOfSlot("getSceneTree(qint64)");
        QVariantList __repc_args;
        __repc_args
            << QVariant::fromValue(id)
        ;
        return QRemoteObjectPendingReply<QString>(sendWithReply(QMetaObject::InvokeMetaMethod, __repc_index, __repc_args));
    }

private:
    friend class QT_PREPEND_NAMESPACE(QRemoteObjectNode);
};


#endif // REP_TREELAND_WINDOWTREE_REPLICA_H
