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

#ifndef WRAPPERS_QPB_H
#define WRAPPERS_QPB_H

#include <QtProtobuf/qprotobuflazymessagepointer.h>
#include <QtProtobuf/qprotobufmessage.h>
#include <QtProtobuf/qprotobufobject.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>

namespace google::protobuf {
class DoubleValue;
using DoubleValueRepeated = QList<DoubleValue>;
namespace DoubleValue_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace DoubleValue_QtProtobufNested

class FloatValue;
using FloatValueRepeated = QList<FloatValue>;
namespace FloatValue_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace FloatValue_QtProtobufNested

class Int64Value;
using Int64ValueRepeated = QList<Int64Value>;
namespace Int64Value_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace Int64Value_QtProtobufNested

class UInt64Value;
using UInt64ValueRepeated = QList<UInt64Value>;
namespace UInt64Value_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace UInt64Value_QtProtobufNested

class Int32Value;
using Int32ValueRepeated = QList<Int32Value>;
namespace Int32Value_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace Int32Value_QtProtobufNested

class UInt32Value;
using UInt32ValueRepeated = QList<UInt32Value>;
namespace UInt32Value_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace UInt32Value_QtProtobufNested

class BoolValue;
using BoolValueRepeated = QList<BoolValue>;
namespace BoolValue_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace BoolValue_QtProtobufNested

class StringValue;
using StringValueRepeated = QList<StringValue>;
namespace StringValue_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace StringValue_QtProtobufNested

class BytesValue;
using BytesValueRepeated = QList<BytesValue>;
namespace BytesValue_QtProtobufNested {
enum class QtProtobufFieldEnum;
} // namespace BytesValue_QtProtobufNested


class DoubleValue_QtProtobufData;
class DoubleValue : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(double value READ value WRITE setValue SCRIPTABLE true)

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

    double value() const;
    void setValue(const double &value);
    static void registerTypes();

private:
    friend bool comparesEqual(const DoubleValue &lhs, const DoubleValue &rhs) noexcept;
    friend bool operator==(const DoubleValue &lhs, const DoubleValue &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const DoubleValue &lhs, const DoubleValue &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<DoubleValue_QtProtobufData> dptr;
};
namespace DoubleValue_QtProtobufNested {
Q_NAMESPACE

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

} // namespace DoubleValue_QtProtobufNested

class FloatValue_QtProtobufData;
class FloatValue : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(float value READ value WRITE setValue SCRIPTABLE true)

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

    float value() const;
    void setValue(const float &value);
    static void registerTypes();

private:
    friend bool comparesEqual(const FloatValue &lhs, const FloatValue &rhs) noexcept;
    friend bool operator==(const FloatValue &lhs, const FloatValue &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const FloatValue &lhs, const FloatValue &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<FloatValue_QtProtobufData> dptr;
};
namespace FloatValue_QtProtobufNested {
Q_NAMESPACE

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

} // namespace FloatValue_QtProtobufNested

class Int64Value_QtProtobufData;
class Int64Value : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(QtProtobuf::int64 value READ value WRITE setValue SCRIPTABLE false)

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

    QtProtobuf::int64 value() const;
    void setValue(const QtProtobuf::int64 &value);
    static void registerTypes();

private:
    friend bool comparesEqual(const Int64Value &lhs, const Int64Value &rhs) noexcept;
    friend bool operator==(const Int64Value &lhs, const Int64Value &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const Int64Value &lhs, const Int64Value &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<Int64Value_QtProtobufData> dptr;
};
namespace Int64Value_QtProtobufNested {
Q_NAMESPACE

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

} // namespace Int64Value_QtProtobufNested

class UInt64Value_QtProtobufData;
class UInt64Value : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(QtProtobuf::uint64 value READ value WRITE setValue SCRIPTABLE true)

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

    QtProtobuf::uint64 value() const;
    void setValue(const QtProtobuf::uint64 &value);
    static void registerTypes();

private:
    friend bool comparesEqual(const UInt64Value &lhs, const UInt64Value &rhs) noexcept;
    friend bool operator==(const UInt64Value &lhs, const UInt64Value &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const UInt64Value &lhs, const UInt64Value &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<UInt64Value_QtProtobufData> dptr;
};
namespace UInt64Value_QtProtobufNested {
Q_NAMESPACE

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

} // namespace UInt64Value_QtProtobufNested

class Int32Value_QtProtobufData;
class Int32Value : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(QtProtobuf::int32 value READ value WRITE setValue SCRIPTABLE true)

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

    QtProtobuf::int32 value() const;
    void setValue(const QtProtobuf::int32 &value);
    static void registerTypes();

private:
    friend bool comparesEqual(const Int32Value &lhs, const Int32Value &rhs) noexcept;
    friend bool operator==(const Int32Value &lhs, const Int32Value &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const Int32Value &lhs, const Int32Value &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<Int32Value_QtProtobufData> dptr;
};
namespace Int32Value_QtProtobufNested {
Q_NAMESPACE

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

} // namespace Int32Value_QtProtobufNested

class UInt32Value_QtProtobufData;
class UInt32Value : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(QtProtobuf::uint32 value READ value WRITE setValue SCRIPTABLE true)

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

    QtProtobuf::uint32 value() const;
    void setValue(const QtProtobuf::uint32 &value);
    static void registerTypes();

private:
    friend bool comparesEqual(const UInt32Value &lhs, const UInt32Value &rhs) noexcept;
    friend bool operator==(const UInt32Value &lhs, const UInt32Value &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const UInt32Value &lhs, const UInt32Value &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<UInt32Value_QtProtobufData> dptr;
};
namespace UInt32Value_QtProtobufNested {
Q_NAMESPACE

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

} // namespace UInt32Value_QtProtobufNested

class BoolValue_QtProtobufData;
class BoolValue : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(bool value READ value WRITE setValue SCRIPTABLE true)

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

    bool value() const;
    void setValue(const bool &value);
    static void registerTypes();

private:
    friend bool comparesEqual(const BoolValue &lhs, const BoolValue &rhs) noexcept;
    friend bool operator==(const BoolValue &lhs, const BoolValue &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const BoolValue &lhs, const BoolValue &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<BoolValue_QtProtobufData> dptr;
};
namespace BoolValue_QtProtobufNested {
Q_NAMESPACE

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

} // namespace BoolValue_QtProtobufNested

class StringValue_QtProtobufData;
class StringValue : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(QString value READ value WRITE setValue SCRIPTABLE true)

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

    QString value() const;
    void setValue(const QString &value);
    static void registerTypes();

private:
    friend bool comparesEqual(const StringValue &lhs, const StringValue &rhs) noexcept;
    friend bool operator==(const StringValue &lhs, const StringValue &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const StringValue &lhs, const StringValue &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<StringValue_QtProtobufData> dptr;
};
namespace StringValue_QtProtobufNested {
Q_NAMESPACE

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

} // namespace StringValue_QtProtobufNested

class BytesValue_QtProtobufData;
class BytesValue : public QProtobufMessage
{
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(QByteArray value READ value WRITE setValue SCRIPTABLE true)

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

    QByteArray value() const;
    void setValue(const QByteArray &value);
    static void registerTypes();

private:
    friend bool comparesEqual(const BytesValue &lhs, const BytesValue &rhs) noexcept;
    friend bool operator==(const BytesValue &lhs, const BytesValue &rhs) noexcept
    {
        return comparesEqual(lhs, rhs);
    }
    friend bool operator!=(const BytesValue &lhs, const BytesValue &rhs) noexcept
    {
        return !comparesEqual(lhs, rhs);
    }
    QExplicitlySharedDataPointer<BytesValue_QtProtobufData> dptr;
};
namespace BytesValue_QtProtobufNested {
Q_NAMESPACE

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

} // namespace BytesValue_QtProtobufNested
} // namespace google::protobuf

#endif // WRAPPERS_QPB_H
