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

#ifndef QTCORE_QPB_H
#define QTCORE_QPB_H

#include "protobufqtcoretypes_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::QtCore {
class QUrl;
using QUrlRepeated = QList<QUrl>;
namespace QUrl_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QUrl_QtProtobufNested

class QChar;
using QCharRepeated = QList<QChar>;
namespace QChar_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QChar_QtProtobufNested

class QUuid;
using QUuidRepeated = QList<QUuid>;
namespace QUuid_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QUuid_QtProtobufNested

class QTimeZone;
using QTimeZoneRepeated = QList<QTimeZone>;
namespace QTimeZone_QtProtobufNested {
enum class QtProtobufFieldEnum;
enum class TimeSpec : int32_t;
using TimeSpecRepeated = QList<TimeSpec>;
enum class TimeZoneFields;
} // namespace QTimeZone_QtProtobufNested

class QTime;
using QTimeRepeated = QList<QTime>;
namespace QTime_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QTime_QtProtobufNested

class QDate;
using QDateRepeated = QList<QDate>;
namespace QDate_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QDate_QtProtobufNested

class QDateTime;
using QDateTimeRepeated = QList<QDateTime>;
namespace QDateTime_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QDateTime_QtProtobufNested

class QSize;
using QSizeRepeated = QList<QSize>;
namespace QSize_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QSize_QtProtobufNested

class QSizeF;
using QSizeFRepeated = QList<QSizeF>;
namespace QSizeF_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QSizeF_QtProtobufNested

class QPoint;
using QPointRepeated = QList<QPoint>;
namespace QPoint_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QPoint_QtProtobufNested

class QPointF;
using QPointFRepeated = QList<QPointF>;
namespace QPointF_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QPointF_QtProtobufNested

class QRect;
using QRectRepeated = QList<QRect>;
namespace QRect_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QRect_QtProtobufNested

class QRectF;
using QRectFRepeated = QList<QRectF>;
namespace QRectF_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QRectF_QtProtobufNested

class QVersionNumber;
using QVersionNumberRepeated = QList<QVersionNumber>;
namespace QVersionNumber_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace QVersionNumber_QtProtobufNested


class QUrl_QtProtobufData;
class QUrl : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QString url READ url WRITE setUrl SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT const QString &url() const &;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setUrl(const QString &url);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setUrl(QString &&url);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QUrl &lhs, const QUrl &rhs) noexcept;
    friend bool operator==(const QUrl &lhs, const QUrl &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QUrl &lhs, const QUrl &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QUrl_QtProtobufData> dptr;
};
namespace QUrl_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

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

} // namespace QUrl_QtProtobufNested

class QChar_QtProtobufData;
class QChar : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::uint32 utf16CodePoint READ utf16CodePoint WRITE setUtf16CodePoint SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::uint32 utf16CodePoint() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setUtf16CodePoint(QtProtobuf::uint32 utf16CodePoint);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QChar &lhs, const QChar &rhs) noexcept;
    friend bool operator==(const QChar &lhs, const QChar &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QChar &lhs, const QChar &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QChar_QtProtobufData> dptr;
};
namespace QChar_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

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

} // namespace QChar_QtProtobufNested

class QUuid_QtProtobufData;
class QUuid : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QByteArray rfc4122Uuid READ rfc4122Uuid WRITE setRfc4122Uuid SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT const QByteArray &rfc4122Uuid() const &;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setRfc4122Uuid(const QByteArray &rfc4122Uuid);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setRfc4122Uuid(QByteArray &&rfc4122Uuid);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QUuid &lhs, const QUuid &rhs) noexcept;
    friend bool operator==(const QUuid &lhs, const QUuid &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QUuid &lhs, const QUuid &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QUuid_QtProtobufData> dptr;
};
namespace QUuid_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

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

} // namespace QUuid_QtProtobufNested

class QTimeZone_QtProtobufData;
class QTimeZone : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::int32 offsetSeconds READ offsetSeconds_p WRITE setOffsetSeconds_p)
    Q_PROPERTY(bool hasOffsetSeconds READ hasOffsetSeconds)
    Q_PROPERTY(QByteArray ianaId READ ianaId_p WRITE setIanaId_p)
    Q_PROPERTY(bool hasIanaId READ hasIanaId)
    Q_PROPERTY(TimeSpec timeSpec READ timeSpec_p WRITE setTimeSpec_p)
    Q_PROPERTY(bool hasTimeSpec READ hasTimeSpec)

public:
    using QtProtobufFieldEnum = QTimeZone_QtProtobufNested::QtProtobufFieldEnum;
    using TimeSpec = QTimeZone_QtProtobufNested::TimeSpec;
    using TimeSpecRepeated = QList<TimeSpec>;
    using TimeZoneFields = QTimeZone_QtProtobufNested::TimeZoneFields;
    QPB_PROTOBUFQTCORETYPES_EXPORT QTimeZone();
    QPB_PROTOBUFQTCORETYPES_EXPORT ~QTimeZone();
    QPB_PROTOBUFQTCORETYPES_EXPORT QTimeZone(const QTimeZone &other);
    QPB_PROTOBUFQTCORETYPES_EXPORT QTimeZone &operator =(const QTimeZone &other);
    QPB_PROTOBUFQTCORETYPES_EXPORT QTimeZone(QTimeZone &&other) noexcept;
    QTimeZone &operator =(QTimeZone &&other) noexcept
    {
        swap(other);
        return *this;
    }
    void swap(QTimeZone &other) noexcept
    {
        QProtobufMessage::swap(other);
        dptr.swap(other.dptr);
    }

    QPB_PROTOBUFQTCORETYPES_EXPORT bool hasOffsetSeconds() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::int32 offsetSeconds() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT bool hasIanaId() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT QByteArray ianaId() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT bool hasTimeSpec() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT QTimeZone_QtProtobufNested::TimeSpec timeSpec() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT TimeZoneFields timeZoneField() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setOffsetSeconds(QtProtobuf::int32 offsetSeconds);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setIanaId(const QByteArray &ianaId);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setIanaId(QByteArray &&ianaId);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setTimeSpec(QTimeZone_QtProtobufNested::TimeSpec timeSpec);
    QPB_PROTOBUFQTCORETYPES_EXPORT void clearTimeZone();
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QTimeZone &lhs, const QTimeZone &rhs) noexcept;
    friend bool operator==(const QTimeZone &lhs, const QTimeZone &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QTimeZone &lhs, const QTimeZone &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::int32 offsetSeconds_p() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT QByteArray ianaId_p() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT QTimeZone_QtProtobufNested::TimeSpec timeSpec_p() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setOffsetSeconds_p(QtProtobuf::int32 offsetSeconds);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setIanaId_p(QByteArray ianaId);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setTimeSpec_p(QTimeZone_QtProtobufNested::TimeSpec timeSpec);
    QExplicitlySharedDataPointer<QTimeZone_QtProtobufData> dptr;
};
namespace QTimeZone_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

enum class QtProtobufFieldEnum {
    OffsetSecondsProtoFieldNumber = 1,
    IanaIdProtoFieldNumber = 2,
    TimeSpecProtoFieldNumber = 3,
};
Q_ENUM_NS(QtProtobufFieldEnum)

enum class TimeSpec : int32_t {
    LocalTime = 0,
    UTC = 1,
};
Q_ENUM_NS(TimeSpec)

using TimeSpecRepeated = QList<TimeSpec>;
enum class TimeZoneFields : int32_t {
    UninitializedField = QtProtobuf::InvalidFieldNumber,
    OffsetSeconds = 1,
    IanaId = 2,
    TimeSpec = 3,
};
Q_ENUM_NS(TimeZoneFields)

} // namespace QTimeZone_QtProtobufNested

class QTime_QtProtobufData;
class QTime : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::int32 millisecondsSinceMidnight READ millisecondsSinceMidnight WRITE setMillisecondsSinceMidnight SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::int32 millisecondsSinceMidnight() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setMillisecondsSinceMidnight(QtProtobuf::int32 millisecondsSinceMidnight);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QTime &lhs, const QTime &rhs) noexcept;
    friend bool operator==(const QTime &lhs, const QTime &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QTime &lhs, const QTime &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QTime_QtProtobufData> dptr;
};
namespace QTime_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

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

} // namespace QTime_QtProtobufNested

class QDate_QtProtobufData;
class QDate : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::int64 julianDay READ julianDay WRITE setJulianDay SCRIPTABLE false)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::int64 julianDay() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setJulianDay(QtProtobuf::int64 julianDay);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QDate &lhs, const QDate &rhs) noexcept;
    friend bool operator==(const QDate &lhs, const QDate &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QDate &lhs, const QDate &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QDate_QtProtobufData> dptr;
};
namespace QDate_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

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

} // namespace QDate_QtProtobufNested

class QDateTime_QtProtobufData;
class QDateTime : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::int64 utcMsecsSinceUnixEpoch READ utcMsecsSinceUnixEpoch WRITE setUtcMsecsSinceUnixEpoch SCRIPTABLE false)
    Q_PROPERTY(QtProtobufPrivate::QtCore::QTimeZone *timeZone_p READ timeZone_p WRITE setTimeZone_p SCRIPTABLE false)
    Q_PROPERTY(bool hasTimeZone READ hasTimeZone)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::int64 utcMsecsSinceUnixEpoch() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT bool hasTimeZone() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT const QTimeZone &timeZone() const &;
    QPB_PROTOBUFQTCORETYPES_EXPORT void clearTimeZone();
    QPB_PROTOBUFQTCORETYPES_EXPORT void setUtcMsecsSinceUnixEpoch(QtProtobuf::int64 utcMsecsSinceUnixEpoch);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setTimeZone(const QTimeZone &timeZone);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setTimeZone(QTimeZone &&timeZone);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QDateTime &lhs, const QDateTime &rhs) noexcept;
    friend bool operator==(const QDateTime &lhs, const QDateTime &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QDateTime &lhs, const QDateTime &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QPB_PROTOBUFQTCORETYPES_EXPORT QTimeZone *timeZone_p();
    QPB_PROTOBUFQTCORETYPES_EXPORT void setTimeZone_p(QTimeZone *timeZone);
    QExplicitlySharedDataPointer<QDateTime_QtProtobufData> dptr;
};
namespace QDateTime_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

enum class QtProtobufFieldEnum {
    UtcMsecsSinceUnixEpochProtoFieldNumber = 1,
    TimeZoneProtoFieldNumber = 2,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QDateTime_QtProtobufNested

class QSize_QtProtobufData;
class QSize : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::int32 width READ width WRITE setWidth SCRIPTABLE true)
    Q_PROPERTY(QtProtobuf::int32 height READ height WRITE setHeight SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::int32 width() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::int32 height() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setWidth(QtProtobuf::int32 width);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setHeight(QtProtobuf::int32 height);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QSize &lhs, const QSize &rhs) noexcept;
    friend bool operator==(const QSize &lhs, const QSize &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QSize &lhs, const QSize &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QSize_QtProtobufData> dptr;
};
namespace QSize_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

enum class QtProtobufFieldEnum {
    WidthProtoFieldNumber = 1,
    HeightProtoFieldNumber = 2,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QSize_QtProtobufNested

class QSizeF_QtProtobufData;
class QSizeF : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(double width READ width WRITE setWidth SCRIPTABLE true)
    Q_PROPERTY(double height READ height WRITE setHeight SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT double width() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT double height() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setWidth(double width);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setHeight(double height);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QSizeF &lhs, const QSizeF &rhs) noexcept;
    friend bool operator==(const QSizeF &lhs, const QSizeF &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QSizeF &lhs, const QSizeF &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QSizeF_QtProtobufData> dptr;
};
namespace QSizeF_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

enum class QtProtobufFieldEnum {
    WidthProtoFieldNumber = 1,
    HeightProtoFieldNumber = 2,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QSizeF_QtProtobufNested

class QPoint_QtProtobufData;
class QPoint : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::sint32 x READ x WRITE setX SCRIPTABLE true)
    Q_PROPERTY(QtProtobuf::sint32 y READ y WRITE setY SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::sint32 x() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::sint32 y() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setX(QtProtobuf::sint32 x);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setY(QtProtobuf::sint32 y);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QPoint &lhs, const QPoint &rhs) noexcept;
    friend bool operator==(const QPoint &lhs, const QPoint &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QPoint &lhs, const QPoint &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QPoint_QtProtobufData> dptr;
};
namespace QPoint_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

enum class QtProtobufFieldEnum {
    XProtoFieldNumber = 1,
    YProtoFieldNumber = 2,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QPoint_QtProtobufNested

class QPointF_QtProtobufData;
class QPointF : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(double x READ x WRITE setX SCRIPTABLE true)
    Q_PROPERTY(double y READ y WRITE setY SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT double x() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT double y() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setX(double x);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setY(double y);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QPointF &lhs, const QPointF &rhs) noexcept;
    friend bool operator==(const QPointF &lhs, const QPointF &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QPointF &lhs, const QPointF &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QPointF_QtProtobufData> dptr;
};
namespace QPointF_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

enum class QtProtobufFieldEnum {
    XProtoFieldNumber = 1,
    YProtoFieldNumber = 2,
};
Q_ENUM_NS(QtProtobufFieldEnum)

} // namespace QPointF_QtProtobufNested

class QRect_QtProtobufData;
class QRect : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::sint32 x READ x WRITE setX SCRIPTABLE true)
    Q_PROPERTY(QtProtobuf::sint32 y READ y WRITE setY SCRIPTABLE true)
    Q_PROPERTY(QtProtobuf::int32 width READ width WRITE setWidth SCRIPTABLE true)
    Q_PROPERTY(QtProtobuf::int32 height READ height WRITE setHeight SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::sint32 x() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::sint32 y() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::int32 width() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT QtProtobuf::int32 height() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setX(QtProtobuf::sint32 x);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setY(QtProtobuf::sint32 y);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setWidth(QtProtobuf::int32 width);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setHeight(QtProtobuf::int32 height);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QRect &lhs, const QRect &rhs) noexcept;
    friend bool operator==(const QRect &lhs, const QRect &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QRect &lhs, const QRect &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QRect_QtProtobufData> dptr;
};
namespace QRect_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

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

} // namespace QRect_QtProtobufNested

class QRectF_QtProtobufData;
class QRectF : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(double x READ x WRITE setX SCRIPTABLE true)
    Q_PROPERTY(double y READ y WRITE setY SCRIPTABLE true)
    Q_PROPERTY(double width READ width WRITE setWidth SCRIPTABLE true)
    Q_PROPERTY(double height READ height WRITE setHeight SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT double x() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT double y() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT double width() const;

    QPB_PROTOBUFQTCORETYPES_EXPORT double height() const;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setX(double x);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setY(double y);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setWidth(double width);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setHeight(double height);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QRectF &lhs, const QRectF &rhs) noexcept;
    friend bool operator==(const QRectF &lhs, const QRectF &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QRectF &lhs, const QRectF &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QRectF_QtProtobufData> dptr;
};
namespace QRectF_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

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

} // namespace QRectF_QtProtobufNested

class QVersionNumber_QtProtobufData;
class QVersionNumber : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)
    Q_PROPERTY(QtProtobuf::int32List segments READ segments WRITE setSegments SCRIPTABLE true)

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

    QPB_PROTOBUFQTCORETYPES_EXPORT const QtProtobuf::int32List &segments() const &;
    QPB_PROTOBUFQTCORETYPES_EXPORT void setSegments(const QtProtobuf::int32List &segments);
    QPB_PROTOBUFQTCORETYPES_EXPORT void setSegments(QtProtobuf::int32List &&segments);
    QPB_PROTOBUFQTCORETYPES_EXPORT static void registerTypes();

private:
    friend QPB_PROTOBUFQTCORETYPES_EXPORT bool comparesEqual(const QVersionNumber &lhs, const QVersionNumber &rhs) noexcept;
    friend bool operator==(const QVersionNumber &lhs, const QVersionNumber &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const QVersionNumber &lhs, const QVersionNumber &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<QVersionNumber_QtProtobufData> dptr;
};
namespace QVersionNumber_QtProtobufNested {
Q_NAMESPACE_EXPORT(QPB_PROTOBUFQTCORETYPES_EXPORT)

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

} // namespace QVersionNumber_QtProtobufNested
} // namespace QtProtobufPrivate::QtCore
QT_END_NAMESPACE

#endif // QTCORE_QPB_H
