/* This file is autogenerated. DO NOT CHANGE. All changes will be lost */

#ifndef QTGUI_QPB_H
#define QTGUI_QPB_H

#include "protobufqtguitypes_exports.qpb.h"

#include <QtProtobuf/qprotobuflazymessagepointer.h>
#include <QtProtobuf/qprotobufmessage.h>
#include <QtProtobuf/qprotobufobject.h>
#include <QtProtobuf/qprotobufoneof.h>
#include <QtProtobuf/qtprotobuftypes.h>

#include <QtCore/qbytearray.h>
#include <QtCore/qlist.h>
#include <QtCore/qmetatype.h>
#include <QtCore/qshareddata.h>
#include <QtCore/qstring.h>

QT_BEGIN_NAMESPACE
namespace QtProtobufPrivate::QtGui {
class QRgba64;
using QRgba64Repeated = QList<QRgba64>;
namespace QRgba64_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QRgba64_QtProtobufNested

class QColor;
using QColorRepeated = QList<QColor>;
namespace QColor_QtProtobufNested {
enum class QtProtobufFieldEnum;
enum class ColorFields;
} // namespace QColor_QtProtobufNested

class QMatrix4x4;
using QMatrix4x4Repeated = QList<QMatrix4x4>;
namespace QMatrix4x4_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QMatrix4x4_QtProtobufNested

class QVector2D;
using QVector2DRepeated = QList<QVector2D>;
namespace QVector2D_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QVector2D_QtProtobufNested

class QVector3D;
using QVector3DRepeated = QList<QVector3D>;
namespace QVector3D_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QVector3D_QtProtobufNested

class QVector4D;
using QVector4DRepeated = QList<QVector4D>;
namespace QVector4D_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QVector4D_QtProtobufNested

class QTransform;
using QTransformRepeated = QList<QTransform>;
namespace QTransform_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QTransform_QtProtobufNested

class QQuaternion;
using QQuaternionRepeated = QList<QQuaternion>;
namespace QQuaternion_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QQuaternion_QtProtobufNested

class QImage;
using QImageRepeated = QList<QImage>;
namespace QImage_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QImage_QtProtobufNested


class QRgba64_QtProtobufData;
class QRgba64 : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::uint64 rgba64 READ rgba64 WRITE setRgba64 SCRIPTABLE true)

public:
    using QtProtobufFieldEnum = QRgba64_QtProtobufNested::QtProtobufFieldEnum;
    QPB_PROTOBUFQTGUITYPES_EXPORT QRgba64();
    QPB_PROTOBUFQTGUITYPES_EXPORT ~QRgba64();
    QPB_PROTOBUFQTGUITYPES_EXPORT QRgba64(const QRgba64 &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QRgba64 &operator =(const QRgba64 &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QRgba64(QRgba64 &&other) noexcept;
    QRgba64 &operator =(QRgba64 &&other) noexcept
    {
        swap(other);
        return *this;
    }
    void swap(QRgba64 &other) noexcept
    {
        QProtobufMessage::swap(other);
        dptr.swap(other.dptr);
    }

    QPB_PROTOBUFQTGUITYPES_EXPORT QtProtobuf::uint64 rgba64() const;
    QPB_PROTOBUFQTGUITYPES_EXPORT void setRgba64(QtProtobuf::uint64 rgba64);
    QPB_PROTOBUFQTGUITYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTGUITYPES_EXPORT bool comparesEqual(const QRgba64 &lhs, const QRgba64 &rhs) noexcept;
    friend bool operator==(const QRgba64 &lhs, const QRgba64 &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QRgba64 &lhs, const QRgba64 &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QRgba64_QtProtobufData> dptr;
};
namespace QRgba64_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)

enum class QtProtobufFieldEnum {
    Rgba64ProtoFieldNumber = 1,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QRgba64_QtProtobufNested

class QColor_QtProtobufData;
class QColor : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)
    Q_PROPERTY(QtProtobufPrivate::QtGui::QRgba64 *rgba64_p READ rgba64_p WRITE setRgba64_p SCRIPTABLE false)
    Q_PROPERTY(bool hasRgba64 READ hasRgba64)
    Q_PROPERTY(QtProtobuf::uint32 rgba READ rgba_p WRITE setRgba_p)
    Q_PROPERTY(bool hasRgba READ hasRgba)

public:
    using QtProtobufFieldEnum = QColor_QtProtobufNested::QtProtobufFieldEnum;
    using ColorFields = QColor_QtProtobufNested::ColorFields;
    QPB_PROTOBUFQTGUITYPES_EXPORT QColor();
    QPB_PROTOBUFQTGUITYPES_EXPORT ~QColor();
    QPB_PROTOBUFQTGUITYPES_EXPORT QColor(const QColor &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QColor &operator =(const QColor &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QColor(QColor &&other) noexcept;
    QColor &operator =(QColor &&other) noexcept
    {
        swap(other);
        return *this;
    }
    void swap(QColor &other) noexcept
    {
        QProtobufMessage::swap(other);
        dptr.swap(other.dptr);
    }

    QPB_PROTOBUFQTGUITYPES_EXPORT bool hasRgba64() const;
    QPB_PROTOBUFQTGUITYPES_EXPORT QRgba64 &rgba64() const;

    QPB_PROTOBUFQTGUITYPES_EXPORT bool hasRgba() const;
    QPB_PROTOBUFQTGUITYPES_EXPORT QtProtobuf::uint32 rgba() const;
    QPB_PROTOBUFQTGUITYPES_EXPORT ColorFields colorField() const;
    QPB_PROTOBUFQTGUITYPES_EXPORT void setRgba64(const QRgba64 &rgba64);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setRgba64(QRgba64 &&rgba64);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setRgba(QtProtobuf::uint32 rgba);
    QPB_PROTOBUFQTGUITYPES_EXPORT void clearColor();
    QPB_PROTOBUFQTGUITYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTGUITYPES_EXPORT bool comparesEqual(const QColor &lhs, const QColor &rhs) noexcept;
    friend bool operator==(const QColor &lhs, const QColor &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QColor &lhs, const QColor &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QPB_PROTOBUFQTGUITYPES_EXPORT QRgba64 *rgba64_p();
    QPB_PROTOBUFQTGUITYPES_EXPORT QtProtobuf::uint32 rgba_p() const;
    QPB_PROTOBUFQTGUITYPES_EXPORT void setRgba64_p(QRgba64 *rgba64);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setRgba_p(QtProtobuf::uint32 rgba);
    QExplicitlySharedDataPointer<QColor_QtProtobufData> dptr;
};
namespace QColor_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)

enum class QtProtobufFieldEnum {
    Rgba64ProtoFieldNumber = 1,
    RgbaProtoFieldNumber = 2,
};
Q_ENUM_NS(QtProtobufFieldEnum)

enum class ColorFields : int32_t {
    UninitializedField = QtProtobuf::InvalidFieldNumber,
    Rgba64 = 1,
    Rgba = 2,
};
Q_ENUM_NS(ColorFields)

} // namespace QColor_QtProtobufNested

class QMatrix4x4_QtProtobufData;
class QMatrix4x4 : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::floatList m READ m WRITE setM SCRIPTABLE true)

public:
    using QtProtobufFieldEnum = QMatrix4x4_QtProtobufNested::QtProtobufFieldEnum;
    QPB_PROTOBUFQTGUITYPES_EXPORT QMatrix4x4();
    QPB_PROTOBUFQTGUITYPES_EXPORT ~QMatrix4x4();
    QPB_PROTOBUFQTGUITYPES_EXPORT QMatrix4x4(const QMatrix4x4 &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QMatrix4x4 &operator =(const QMatrix4x4 &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QMatrix4x4(QMatrix4x4 &&other) noexcept;
    QMatrix4x4 &operator =(QMatrix4x4 &&other) noexcept
    {
        swap(other);
        return *this;
    }
    void swap(QMatrix4x4 &other) noexcept
    {
        QProtobufMessage::swap(other);
        dptr.swap(other.dptr);
    }

    QPB_PROTOBUFQTGUITYPES_EXPORT const QtProtobuf::floatList &m() const &;
    QPB_PROTOBUFQTGUITYPES_EXPORT void setM(const QtProtobuf::floatList &m);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setM(QtProtobuf::floatList &&m);
    QPB_PROTOBUFQTGUITYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTGUITYPES_EXPORT bool comparesEqual(const QMatrix4x4 &lhs, const QMatrix4x4 &rhs) noexcept;
    friend bool operator==(const QMatrix4x4 &lhs, const QMatrix4x4 &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QMatrix4x4 &lhs, const QMatrix4x4 &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QMatrix4x4_QtProtobufData> dptr;
};
namespace QMatrix4x4_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)

enum class QtProtobufFieldEnum {
    MProtoFieldNumber = 1,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QMatrix4x4_QtProtobufNested

class QVector2D_QtProtobufData;
class QVector2D : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)
    Q_PROPERTY(float xPos READ xPos WRITE setXPos SCRIPTABLE true)
    Q_PROPERTY(float yPos READ yPos WRITE setYPos SCRIPTABLE true)

public:
    using QtProtobufFieldEnum = QVector2D_QtProtobufNested::QtProtobufFieldEnum;
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector2D();
    QPB_PROTOBUFQTGUITYPES_EXPORT ~QVector2D();
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector2D(const QVector2D &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector2D &operator =(const QVector2D &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector2D(QVector2D &&other) noexcept;
    QVector2D &operator =(QVector2D &&other) noexcept
    {
        swap(other);
        return *this;
    }
    void swap(QVector2D &other) noexcept
    {
        QProtobufMessage::swap(other);
        dptr.swap(other.dptr);
    }

    QPB_PROTOBUFQTGUITYPES_EXPORT float xPos() const;

    QPB_PROTOBUFQTGUITYPES_EXPORT float yPos() const;
    QPB_PROTOBUFQTGUITYPES_EXPORT void setXPos(float xPos);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setYPos(float yPos);
    QPB_PROTOBUFQTGUITYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTGUITYPES_EXPORT bool comparesEqual(const QVector2D &lhs, const QVector2D &rhs) noexcept;
    friend bool operator==(const QVector2D &lhs, const QVector2D &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QVector2D &lhs, const QVector2D &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QVector2D_QtProtobufData> dptr;
};
namespace QVector2D_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)

enum class QtProtobufFieldEnum {
    XPosProtoFieldNumber = 1,
    YPosProtoFieldNumber = 2,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QVector2D_QtProtobufNested

class QVector3D_QtProtobufData;
class QVector3D : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)
    Q_PROPERTY(float xPos READ xPos WRITE setXPos SCRIPTABLE true)
    Q_PROPERTY(float yPos READ yPos WRITE setYPos SCRIPTABLE true)
    Q_PROPERTY(float zPos READ zPos WRITE setZPos SCRIPTABLE true)

public:
    using QtProtobufFieldEnum = QVector3D_QtProtobufNested::QtProtobufFieldEnum;
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector3D();
    QPB_PROTOBUFQTGUITYPES_EXPORT ~QVector3D();
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector3D(const QVector3D &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector3D &operator =(const QVector3D &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector3D(QVector3D &&other) noexcept;
    QVector3D &operator =(QVector3D &&other) noexcept
    {
        swap(other);
        return *this;
    }
    void swap(QVector3D &other) noexcept
    {
        QProtobufMessage::swap(other);
        dptr.swap(other.dptr);
    }

    QPB_PROTOBUFQTGUITYPES_EXPORT float xPos() const;

    QPB_PROTOBUFQTGUITYPES_EXPORT float yPos() const;

    QPB_PROTOBUFQTGUITYPES_EXPORT float zPos() const;
    QPB_PROTOBUFQTGUITYPES_EXPORT void setXPos(float xPos);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setYPos(float yPos);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setZPos(float zPos);
    QPB_PROTOBUFQTGUITYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTGUITYPES_EXPORT bool comparesEqual(const QVector3D &lhs, const QVector3D &rhs) noexcept;
    friend bool operator==(const QVector3D &lhs, const QVector3D &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QVector3D &lhs, const QVector3D &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QVector3D_QtProtobufData> dptr;
};
namespace QVector3D_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)

enum class QtProtobufFieldEnum {
    XPosProtoFieldNumber = 1,
    YPosProtoFieldNumber = 2,
    ZPosProtoFieldNumber = 3,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QVector3D_QtProtobufNested

class QVector4D_QtProtobufData;
class QVector4D : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)
    Q_PROPERTY(float xPos READ xPos WRITE setXPos SCRIPTABLE true)
    Q_PROPERTY(float yPos READ yPos WRITE setYPos SCRIPTABLE true)
    Q_PROPERTY(float zPos READ zPos WRITE setZPos SCRIPTABLE true)
    Q_PROPERTY(float wPos READ wPos WRITE setWPos SCRIPTABLE true)

public:
    using QtProtobufFieldEnum = QVector4D_QtProtobufNested::QtProtobufFieldEnum;
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector4D();
    QPB_PROTOBUFQTGUITYPES_EXPORT ~QVector4D();
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector4D(const QVector4D &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector4D &operator =(const QVector4D &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QVector4D(QVector4D &&other) noexcept;
    QVector4D &operator =(QVector4D &&other) noexcept
    {
        swap(other);
        return *this;
    }
    void swap(QVector4D &other) noexcept
    {
        QProtobufMessage::swap(other);
        dptr.swap(other.dptr);
    }

    QPB_PROTOBUFQTGUITYPES_EXPORT float xPos() const;

    QPB_PROTOBUFQTGUITYPES_EXPORT float yPos() const;

    QPB_PROTOBUFQTGUITYPES_EXPORT float zPos() const;

    QPB_PROTOBUFQTGUITYPES_EXPORT float wPos() const;
    QPB_PROTOBUFQTGUITYPES_EXPORT void setXPos(float xPos);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setYPos(float yPos);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setZPos(float zPos);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setWPos(float wPos);
    QPB_PROTOBUFQTGUITYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTGUITYPES_EXPORT bool comparesEqual(const QVector4D &lhs, const QVector4D &rhs) noexcept;
    friend bool operator==(const QVector4D &lhs, const QVector4D &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QVector4D &lhs, const QVector4D &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QVector4D_QtProtobufData> dptr;
};
namespace QVector4D_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)

enum class QtProtobufFieldEnum {
    XPosProtoFieldNumber = 1,
    YPosProtoFieldNumber = 2,
    ZPosProtoFieldNumber = 3,
    WPosProtoFieldNumber = 4,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QVector4D_QtProtobufNested

class QTransform_QtProtobufData;
class QTransform : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::doubleList m READ m WRITE setM SCRIPTABLE true)

public:
    using QtProtobufFieldEnum = QTransform_QtProtobufNested::QtProtobufFieldEnum;
    QPB_PROTOBUFQTGUITYPES_EXPORT QTransform();
    QPB_PROTOBUFQTGUITYPES_EXPORT ~QTransform();
    QPB_PROTOBUFQTGUITYPES_EXPORT QTransform(const QTransform &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QTransform &operator =(const QTransform &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QTransform(QTransform &&other) noexcept;
    QTransform &operator =(QTransform &&other) noexcept
    {
        swap(other);
        return *this;
    }
    void swap(QTransform &other) noexcept
    {
        QProtobufMessage::swap(other);
        dptr.swap(other.dptr);
    }

    QPB_PROTOBUFQTGUITYPES_EXPORT const QtProtobuf::doubleList &m() const &;
    QPB_PROTOBUFQTGUITYPES_EXPORT void setM(const QtProtobuf::doubleList &m);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setM(QtProtobuf::doubleList &&m);
    QPB_PROTOBUFQTGUITYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTGUITYPES_EXPORT bool comparesEqual(const QTransform &lhs, const QTransform &rhs) noexcept;
    friend bool operator==(const QTransform &lhs, const QTransform &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QTransform &lhs, const QTransform &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QTransform_QtProtobufData> dptr;
};
namespace QTransform_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)

enum class QtProtobufFieldEnum {
    MProtoFieldNumber = 1,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QTransform_QtProtobufNested

class QQuaternion_QtProtobufData;
class QQuaternion : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)
    Q_PROPERTY(float scalar READ scalar WRITE setScalar SCRIPTABLE true)
    Q_PROPERTY(float x READ x WRITE setX SCRIPTABLE true)
    Q_PROPERTY(float y READ y WRITE setY SCRIPTABLE true)
    Q_PROPERTY(float z READ z WRITE setZ SCRIPTABLE true)

public:
    using QtProtobufFieldEnum = QQuaternion_QtProtobufNested::QtProtobufFieldEnum;
    QPB_PROTOBUFQTGUITYPES_EXPORT QQuaternion();
    QPB_PROTOBUFQTGUITYPES_EXPORT ~QQuaternion();
    QPB_PROTOBUFQTGUITYPES_EXPORT QQuaternion(const QQuaternion &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QQuaternion &operator =(const QQuaternion &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QQuaternion(QQuaternion &&other) noexcept;
    QQuaternion &operator =(QQuaternion &&other) noexcept
    {
        swap(other);
        return *this;
    }
    void swap(QQuaternion &other) noexcept
    {
        QProtobufMessage::swap(other);
        dptr.swap(other.dptr);
    }

    QPB_PROTOBUFQTGUITYPES_EXPORT float scalar() const;

    QPB_PROTOBUFQTGUITYPES_EXPORT float x() const;

    QPB_PROTOBUFQTGUITYPES_EXPORT float y() const;

    QPB_PROTOBUFQTGUITYPES_EXPORT float z() const;
    QPB_PROTOBUFQTGUITYPES_EXPORT void setScalar(float scalar);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setX(float x);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setY(float y);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setZ(float z);
    QPB_PROTOBUFQTGUITYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTGUITYPES_EXPORT bool comparesEqual(const QQuaternion &lhs, const QQuaternion &rhs) noexcept;
    friend bool operator==(const QQuaternion &lhs, const QQuaternion &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QQuaternion &lhs, const QQuaternion &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QQuaternion_QtProtobufData> dptr;
};
namespace QQuaternion_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)

enum class QtProtobufFieldEnum {
    ScalarProtoFieldNumber = 1,
    XProtoFieldNumber = 2,
    YProtoFieldNumber = 3,
    ZProtoFieldNumber = 4,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QQuaternion_QtProtobufNested

class QImage_QtProtobufData;
class QImage : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)
    Q_PROPERTY(QByteArray data READ data WRITE setData SCRIPTABLE true)
    Q_PROPERTY(QString format READ format WRITE setFormat SCRIPTABLE true)

public:
    using QtProtobufFieldEnum = QImage_QtProtobufNested::QtProtobufFieldEnum;
    QPB_PROTOBUFQTGUITYPES_EXPORT QImage();
    QPB_PROTOBUFQTGUITYPES_EXPORT ~QImage();
    QPB_PROTOBUFQTGUITYPES_EXPORT QImage(const QImage &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QImage &operator =(const QImage &other);
    QPB_PROTOBUFQTGUITYPES_EXPORT QImage(QImage &&other) noexcept;
    QImage &operator =(QImage &&other) noexcept
    {
        swap(other);
        return *this;
    }
    void swap(QImage &other) noexcept
    {
        QProtobufMessage::swap(other);
        dptr.swap(other.dptr);
    }

    QPB_PROTOBUFQTGUITYPES_EXPORT const QByteArray &data() const &;

    QPB_PROTOBUFQTGUITYPES_EXPORT const QString &format() const &;
    QPB_PROTOBUFQTGUITYPES_EXPORT void setData(const QByteArray &data);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setData(QByteArray &&data);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setFormat(const QString &format);
    QPB_PROTOBUFQTGUITYPES_EXPORT void setFormat(QString &&format);
    QPB_PROTOBUFQTGUITYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTGUITYPES_EXPORT bool comparesEqual(const QImage &lhs, const QImage &rhs) noexcept;
    friend bool operator==(const QImage &lhs, const QImage &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QImage &lhs, const QImage &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QImage_QtProtobufData> dptr;
};
namespace QImage_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTGUITYPES_EXPORT)

enum class QtProtobufFieldEnum {
    DataProtoFieldNumber = 1,
    FormatProtoFieldNumber = 2,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QImage_QtProtobufNested
} // namespace QtProtobufPrivate::QtGui
QT_END_NAMESPACE

#endif // QTGUI_QPB_H
