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

#ifndef Q_PROTOBUF_mapmessages_H
#define Q_PROTOBUF_mapmessages_H

#include <QtCore/QObject>
#include <QtCore/QMetaType>
#include <QtCore/QList>

#include <QtProtobuf/qprotobufobject.h>
#include <QtProtobuf/qprotobuflazymessagepointer.h>

#include <memory>

#include <QByteArray>
#include <QString>
#include "basicmessages.qpb.h"


namespace qtprotobufnamespace::tests {
class SimpleSInt32StringMapMessage;
using SimpleSInt32StringMapMessageRepeated = QList<std::shared_ptr<SimpleSInt32StringMapMessage>>;
class SimpleSInt64StringMapMessage;
using SimpleSInt64StringMapMessageRepeated = QList<std::shared_ptr<SimpleSInt64StringMapMessage>>;
class SimpleInt32StringMapMessage;
using SimpleInt32StringMapMessageRepeated = QList<std::shared_ptr<SimpleInt32StringMapMessage>>;
class SimpleInt64StringMapMessage;
using SimpleInt64StringMapMessageRepeated = QList<std::shared_ptr<SimpleInt64StringMapMessage>>;
class SimpleUInt32StringMapMessage;
using SimpleUInt32StringMapMessageRepeated = QList<std::shared_ptr<SimpleUInt32StringMapMessage>>;
class SimpleUInt64StringMapMessage;
using SimpleUInt64StringMapMessageRepeated = QList<std::shared_ptr<SimpleUInt64StringMapMessage>>;
class SimpleFixed32StringMapMessage;
using SimpleFixed32StringMapMessageRepeated = QList<std::shared_ptr<SimpleFixed32StringMapMessage>>;
class SimpleFixed64StringMapMessage;
using SimpleFixed64StringMapMessageRepeated = QList<std::shared_ptr<SimpleFixed64StringMapMessage>>;
class SimpleSFixed32StringMapMessage;
using SimpleSFixed32StringMapMessageRepeated = QList<std::shared_ptr<SimpleSFixed32StringMapMessage>>;
class SimpleSFixed64StringMapMessage;
using SimpleSFixed64StringMapMessageRepeated = QList<std::shared_ptr<SimpleSFixed64StringMapMessage>>;
class SimpleStringStringMapMessage;
using SimpleStringStringMapMessageRepeated = QList<std::shared_ptr<SimpleStringStringMapMessage>>;
class SimpleSInt32SInt32MapMessage;
using SimpleSInt32SInt32MapMessageRepeated = QList<std::shared_ptr<SimpleSInt32SInt32MapMessage>>;
class SimpleSInt64SInt32MapMessage;
using SimpleSInt64SInt32MapMessageRepeated = QList<std::shared_ptr<SimpleSInt64SInt32MapMessage>>;
class SimpleInt32SInt32MapMessage;
using SimpleInt32SInt32MapMessageRepeated = QList<std::shared_ptr<SimpleInt32SInt32MapMessage>>;
class SimpleInt64SInt32MapMessage;
using SimpleInt64SInt32MapMessageRepeated = QList<std::shared_ptr<SimpleInt64SInt32MapMessage>>;
class SimpleUInt32SInt32MapMessage;
using SimpleUInt32SInt32MapMessageRepeated = QList<std::shared_ptr<SimpleUInt32SInt32MapMessage>>;
class SimpleUInt64SInt32MapMessage;
using SimpleUInt64SInt32MapMessageRepeated = QList<std::shared_ptr<SimpleUInt64SInt32MapMessage>>;
class SimpleFixed32SInt32MapMessage;
using SimpleFixed32SInt32MapMessageRepeated = QList<std::shared_ptr<SimpleFixed32SInt32MapMessage>>;
class SimpleFixed64SInt32MapMessage;
using SimpleFixed64SInt32MapMessageRepeated = QList<std::shared_ptr<SimpleFixed64SInt32MapMessage>>;
class SimpleSFixed32SInt32MapMessage;
using SimpleSFixed32SInt32MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed32SInt32MapMessage>>;
class SimpleSFixed64SInt32MapMessage;
using SimpleSFixed64SInt32MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed64SInt32MapMessage>>;
class SimpleStringSInt32MapMessage;
using SimpleStringSInt32MapMessageRepeated = QList<std::shared_ptr<SimpleStringSInt32MapMessage>>;
class SimpleSInt32SInt64MapMessage;
using SimpleSInt32SInt64MapMessageRepeated = QList<std::shared_ptr<SimpleSInt32SInt64MapMessage>>;
class SimpleSInt64SInt64MapMessage;
using SimpleSInt64SInt64MapMessageRepeated = QList<std::shared_ptr<SimpleSInt64SInt64MapMessage>>;
class SimpleInt32SInt64MapMessage;
using SimpleInt32SInt64MapMessageRepeated = QList<std::shared_ptr<SimpleInt32SInt64MapMessage>>;
class SimpleInt64SInt64MapMessage;
using SimpleInt64SInt64MapMessageRepeated = QList<std::shared_ptr<SimpleInt64SInt64MapMessage>>;
class SimpleUInt32SInt64MapMessage;
using SimpleUInt32SInt64MapMessageRepeated = QList<std::shared_ptr<SimpleUInt32SInt64MapMessage>>;
class SimpleUInt64SInt64MapMessage;
using SimpleUInt64SInt64MapMessageRepeated = QList<std::shared_ptr<SimpleUInt64SInt64MapMessage>>;
class SimpleFixed32SInt64MapMessage;
using SimpleFixed32SInt64MapMessageRepeated = QList<std::shared_ptr<SimpleFixed32SInt64MapMessage>>;
class SimpleFixed64SInt64MapMessage;
using SimpleFixed64SInt64MapMessageRepeated = QList<std::shared_ptr<SimpleFixed64SInt64MapMessage>>;
class SimpleSFixed32SInt64MapMessage;
using SimpleSFixed32SInt64MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed32SInt64MapMessage>>;
class SimpleSFixed64SInt64MapMessage;
using SimpleSFixed64SInt64MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed64SInt64MapMessage>>;
class SimpleStringSInt64MapMessage;
using SimpleStringSInt64MapMessageRepeated = QList<std::shared_ptr<SimpleStringSInt64MapMessage>>;
class SimpleSInt32UInt32MapMessage;
using SimpleSInt32UInt32MapMessageRepeated = QList<std::shared_ptr<SimpleSInt32UInt32MapMessage>>;
class SimpleSInt64UInt32MapMessage;
using SimpleSInt64UInt32MapMessageRepeated = QList<std::shared_ptr<SimpleSInt64UInt32MapMessage>>;
class SimpleInt32UInt32MapMessage;
using SimpleInt32UInt32MapMessageRepeated = QList<std::shared_ptr<SimpleInt32UInt32MapMessage>>;
class SimpleInt64UInt32MapMessage;
using SimpleInt64UInt32MapMessageRepeated = QList<std::shared_ptr<SimpleInt64UInt32MapMessage>>;
class SimpleUInt32UInt32MapMessage;
using SimpleUInt32UInt32MapMessageRepeated = QList<std::shared_ptr<SimpleUInt32UInt32MapMessage>>;
class SimpleUInt64UInt32MapMessage;
using SimpleUInt64UInt32MapMessageRepeated = QList<std::shared_ptr<SimpleUInt64UInt32MapMessage>>;
class SimpleFixed32UInt32MapMessage;
using SimpleFixed32UInt32MapMessageRepeated = QList<std::shared_ptr<SimpleFixed32UInt32MapMessage>>;
class SimpleFixed64UInt32MapMessage;
using SimpleFixed64UInt32MapMessageRepeated = QList<std::shared_ptr<SimpleFixed64UInt32MapMessage>>;
class SimpleSFixed32UInt32MapMessage;
using SimpleSFixed32UInt32MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed32UInt32MapMessage>>;
class SimpleSFixed64UInt32MapMessage;
using SimpleSFixed64UInt32MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed64UInt32MapMessage>>;
class SimpleStringUInt32MapMessage;
using SimpleStringUInt32MapMessageRepeated = QList<std::shared_ptr<SimpleStringUInt32MapMessage>>;
class SimpleSInt32UInt64MapMessage;
using SimpleSInt32UInt64MapMessageRepeated = QList<std::shared_ptr<SimpleSInt32UInt64MapMessage>>;
class SimpleSInt64UInt64MapMessage;
using SimpleSInt64UInt64MapMessageRepeated = QList<std::shared_ptr<SimpleSInt64UInt64MapMessage>>;
class SimpleInt32UInt64MapMessage;
using SimpleInt32UInt64MapMessageRepeated = QList<std::shared_ptr<SimpleInt32UInt64MapMessage>>;
class SimpleInt64UInt64MapMessage;
using SimpleInt64UInt64MapMessageRepeated = QList<std::shared_ptr<SimpleInt64UInt64MapMessage>>;
class SimpleUInt32UInt64MapMessage;
using SimpleUInt32UInt64MapMessageRepeated = QList<std::shared_ptr<SimpleUInt32UInt64MapMessage>>;
class SimpleUInt64UInt64MapMessage;
using SimpleUInt64UInt64MapMessageRepeated = QList<std::shared_ptr<SimpleUInt64UInt64MapMessage>>;
class SimpleFixed32UInt64MapMessage;
using SimpleFixed32UInt64MapMessageRepeated = QList<std::shared_ptr<SimpleFixed32UInt64MapMessage>>;
class SimpleFixed64UInt64MapMessage;
using SimpleFixed64UInt64MapMessageRepeated = QList<std::shared_ptr<SimpleFixed64UInt64MapMessage>>;
class SimpleSFixed32UInt64MapMessage;
using SimpleSFixed32UInt64MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed32UInt64MapMessage>>;
class SimpleSFixed64UInt64MapMessage;
using SimpleSFixed64UInt64MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed64UInt64MapMessage>>;
class SimpleStringUInt64MapMessage;
using SimpleStringUInt64MapMessageRepeated = QList<std::shared_ptr<SimpleStringUInt64MapMessage>>;
class SimpleSInt32Int32MapMessage;
using SimpleSInt32Int32MapMessageRepeated = QList<std::shared_ptr<SimpleSInt32Int32MapMessage>>;
class SimpleSInt64Int32MapMessage;
using SimpleSInt64Int32MapMessageRepeated = QList<std::shared_ptr<SimpleSInt64Int32MapMessage>>;
class SimpleInt32Int32MapMessage;
using SimpleInt32Int32MapMessageRepeated = QList<std::shared_ptr<SimpleInt32Int32MapMessage>>;
class SimpleInt64Int32MapMessage;
using SimpleInt64Int32MapMessageRepeated = QList<std::shared_ptr<SimpleInt64Int32MapMessage>>;
class SimpleUInt32Int32MapMessage;
using SimpleUInt32Int32MapMessageRepeated = QList<std::shared_ptr<SimpleUInt32Int32MapMessage>>;
class SimpleUInt64Int32MapMessage;
using SimpleUInt64Int32MapMessageRepeated = QList<std::shared_ptr<SimpleUInt64Int32MapMessage>>;
class SimpleFixed32Int32MapMessage;
using SimpleFixed32Int32MapMessageRepeated = QList<std::shared_ptr<SimpleFixed32Int32MapMessage>>;
class SimpleFixed64Int32MapMessage;
using SimpleFixed64Int32MapMessageRepeated = QList<std::shared_ptr<SimpleFixed64Int32MapMessage>>;
class SimpleSFixed32Int32MapMessage;
using SimpleSFixed32Int32MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed32Int32MapMessage>>;
class SimpleSFixed64Int32MapMessage;
using SimpleSFixed64Int32MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed64Int32MapMessage>>;
class SimpleStringInt32MapMessage;
using SimpleStringInt32MapMessageRepeated = QList<std::shared_ptr<SimpleStringInt32MapMessage>>;
class SimpleSInt32Int64MapMessage;
using SimpleSInt32Int64MapMessageRepeated = QList<std::shared_ptr<SimpleSInt32Int64MapMessage>>;
class SimpleSInt64Int64MapMessage;
using SimpleSInt64Int64MapMessageRepeated = QList<std::shared_ptr<SimpleSInt64Int64MapMessage>>;
class SimpleInt32Int64MapMessage;
using SimpleInt32Int64MapMessageRepeated = QList<std::shared_ptr<SimpleInt32Int64MapMessage>>;
class SimpleInt64Int64MapMessage;
using SimpleInt64Int64MapMessageRepeated = QList<std::shared_ptr<SimpleInt64Int64MapMessage>>;
class SimpleUInt32Int64MapMessage;
using SimpleUInt32Int64MapMessageRepeated = QList<std::shared_ptr<SimpleUInt32Int64MapMessage>>;
class SimpleUInt64Int64MapMessage;
using SimpleUInt64Int64MapMessageRepeated = QList<std::shared_ptr<SimpleUInt64Int64MapMessage>>;
class SimpleFixed32Int64MapMessage;
using SimpleFixed32Int64MapMessageRepeated = QList<std::shared_ptr<SimpleFixed32Int64MapMessage>>;
class SimpleFixed64Int64MapMessage;
using SimpleFixed64Int64MapMessageRepeated = QList<std::shared_ptr<SimpleFixed64Int64MapMessage>>;
class SimpleSFixed32Int64MapMessage;
using SimpleSFixed32Int64MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed32Int64MapMessage>>;
class SimpleSFixed64Int64MapMessage;
using SimpleSFixed64Int64MapMessageRepeated = QList<std::shared_ptr<SimpleSFixed64Int64MapMessage>>;
class SimpleStringInt64MapMessage;
using SimpleStringInt64MapMessageRepeated = QList<std::shared_ptr<SimpleStringInt64MapMessage>>;
class SimpleSInt32ComplexMessageMapMessage;
using SimpleSInt32ComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleSInt32ComplexMessageMapMessage>>;
class SimpleSInt64ComplexMessageMapMessage;
using SimpleSInt64ComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleSInt64ComplexMessageMapMessage>>;
class SimpleInt32ComplexMessageMapMessage;
using SimpleInt32ComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleInt32ComplexMessageMapMessage>>;
class SimpleInt64ComplexMessageMapMessage;
using SimpleInt64ComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleInt64ComplexMessageMapMessage>>;
class SimpleUInt32ComplexMessageMapMessage;
using SimpleUInt32ComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleUInt32ComplexMessageMapMessage>>;
class SimpleUInt64ComplexMessageMapMessage;
using SimpleUInt64ComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleUInt64ComplexMessageMapMessage>>;
class SimpleFixed32ComplexMessageMapMessage;
using SimpleFixed32ComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleFixed32ComplexMessageMapMessage>>;
class SimpleFixed64ComplexMessageMapMessage;
using SimpleFixed64ComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleFixed64ComplexMessageMapMessage>>;
class SimpleSFixed32ComplexMessageMapMessage;
using SimpleSFixed32ComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleSFixed32ComplexMessageMapMessage>>;
class SimpleSFixed64ComplexMessageMapMessage;
using SimpleSFixed64ComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleSFixed64ComplexMessageMapMessage>>;
class SimpleStringComplexMessageMapMessage;
using SimpleStringComplexMessageMapMessageRepeated = QList<std::shared_ptr<SimpleStringComplexMessageMapMessage>>;

class  SimpleSInt32StringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt32StringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 1,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint32, QString>;
    SimpleSInt32StringMapMessage(QObject *parent = nullptr);
    ~SimpleSInt32StringMapMessage() override;
    SimpleSInt32StringMapMessage(const SimpleSInt32StringMapMessage &other);
    SimpleSInt32StringMapMessage &operator =(const SimpleSInt32StringMapMessage &other);
    SimpleSInt32StringMapMessage(SimpleSInt32StringMapMessage &&other) noexcept;
    SimpleSInt32StringMapMessage &operator =(SimpleSInt32StringMapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt32StringMapMessage &other) const;
    bool operator !=(const SimpleSInt32StringMapMessage &other) const;

    SimpleSInt32StringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt32StringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt32StringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt32StringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt64StringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt64StringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 2,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint64, QString>;
    SimpleSInt64StringMapMessage(QObject *parent = nullptr);
    ~SimpleSInt64StringMapMessage() override;
    SimpleSInt64StringMapMessage(const SimpleSInt64StringMapMessage &other);
    SimpleSInt64StringMapMessage &operator =(const SimpleSInt64StringMapMessage &other);
    SimpleSInt64StringMapMessage(SimpleSInt64StringMapMessage &&other) noexcept;
    SimpleSInt64StringMapMessage &operator =(SimpleSInt64StringMapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt64StringMapMessage &other) const;
    bool operator !=(const SimpleSInt64StringMapMessage &other) const;

    SimpleSInt64StringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt64StringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt64StringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt64StringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt32StringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt32StringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 3,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int32, QString>;
    SimpleInt32StringMapMessage(QObject *parent = nullptr);
    ~SimpleInt32StringMapMessage() override;
    SimpleInt32StringMapMessage(const SimpleInt32StringMapMessage &other);
    SimpleInt32StringMapMessage &operator =(const SimpleInt32StringMapMessage &other);
    SimpleInt32StringMapMessage(SimpleInt32StringMapMessage &&other) noexcept;
    SimpleInt32StringMapMessage &operator =(SimpleInt32StringMapMessage &&other) noexcept;
    bool operator ==(const SimpleInt32StringMapMessage &other) const;
    bool operator !=(const SimpleInt32StringMapMessage &other) const;

    SimpleInt32StringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt32StringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt32StringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt32StringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt64StringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt64StringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 4,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int64, QString>;
    SimpleInt64StringMapMessage(QObject *parent = nullptr);
    ~SimpleInt64StringMapMessage() override;
    SimpleInt64StringMapMessage(const SimpleInt64StringMapMessage &other);
    SimpleInt64StringMapMessage &operator =(const SimpleInt64StringMapMessage &other);
    SimpleInt64StringMapMessage(SimpleInt64StringMapMessage &&other) noexcept;
    SimpleInt64StringMapMessage &operator =(SimpleInt64StringMapMessage &&other) noexcept;
    bool operator ==(const SimpleInt64StringMapMessage &other) const;
    bool operator !=(const SimpleInt64StringMapMessage &other) const;

    SimpleInt64StringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt64StringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt64StringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt64StringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt32StringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt32StringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 5,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint32, QString>;
    SimpleUInt32StringMapMessage(QObject *parent = nullptr);
    ~SimpleUInt32StringMapMessage() override;
    SimpleUInt32StringMapMessage(const SimpleUInt32StringMapMessage &other);
    SimpleUInt32StringMapMessage &operator =(const SimpleUInt32StringMapMessage &other);
    SimpleUInt32StringMapMessage(SimpleUInt32StringMapMessage &&other) noexcept;
    SimpleUInt32StringMapMessage &operator =(SimpleUInt32StringMapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt32StringMapMessage &other) const;
    bool operator !=(const SimpleUInt32StringMapMessage &other) const;

    SimpleUInt32StringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt32StringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt32StringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt32StringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt64StringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt64StringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 6,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint64, QString>;
    SimpleUInt64StringMapMessage(QObject *parent = nullptr);
    ~SimpleUInt64StringMapMessage() override;
    SimpleUInt64StringMapMessage(const SimpleUInt64StringMapMessage &other);
    SimpleUInt64StringMapMessage &operator =(const SimpleUInt64StringMapMessage &other);
    SimpleUInt64StringMapMessage(SimpleUInt64StringMapMessage &&other) noexcept;
    SimpleUInt64StringMapMessage &operator =(SimpleUInt64StringMapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt64StringMapMessage &other) const;
    bool operator !=(const SimpleUInt64StringMapMessage &other) const;

    SimpleUInt64StringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt64StringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt64StringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt64StringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed32StringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed32StringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 7,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed32, QString>;
    SimpleFixed32StringMapMessage(QObject *parent = nullptr);
    ~SimpleFixed32StringMapMessage() override;
    SimpleFixed32StringMapMessage(const SimpleFixed32StringMapMessage &other);
    SimpleFixed32StringMapMessage &operator =(const SimpleFixed32StringMapMessage &other);
    SimpleFixed32StringMapMessage(SimpleFixed32StringMapMessage &&other) noexcept;
    SimpleFixed32StringMapMessage &operator =(SimpleFixed32StringMapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed32StringMapMessage &other) const;
    bool operator !=(const SimpleFixed32StringMapMessage &other) const;

    SimpleFixed32StringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed32StringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed32StringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed32StringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed64StringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed64StringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 8,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed64, QString>;
    SimpleFixed64StringMapMessage(QObject *parent = nullptr);
    ~SimpleFixed64StringMapMessage() override;
    SimpleFixed64StringMapMessage(const SimpleFixed64StringMapMessage &other);
    SimpleFixed64StringMapMessage &operator =(const SimpleFixed64StringMapMessage &other);
    SimpleFixed64StringMapMessage(SimpleFixed64StringMapMessage &&other) noexcept;
    SimpleFixed64StringMapMessage &operator =(SimpleFixed64StringMapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed64StringMapMessage &other) const;
    bool operator !=(const SimpleFixed64StringMapMessage &other) const;

    SimpleFixed64StringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed64StringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed64StringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed64StringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed32StringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed32StringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 9,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed32, QString>;
    SimpleSFixed32StringMapMessage(QObject *parent = nullptr);
    ~SimpleSFixed32StringMapMessage() override;
    SimpleSFixed32StringMapMessage(const SimpleSFixed32StringMapMessage &other);
    SimpleSFixed32StringMapMessage &operator =(const SimpleSFixed32StringMapMessage &other);
    SimpleSFixed32StringMapMessage(SimpleSFixed32StringMapMessage &&other) noexcept;
    SimpleSFixed32StringMapMessage &operator =(SimpleSFixed32StringMapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed32StringMapMessage &other) const;
    bool operator !=(const SimpleSFixed32StringMapMessage &other) const;

    SimpleSFixed32StringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed32StringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed32StringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed32StringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed64StringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed64StringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 10,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed64, QString>;
    SimpleSFixed64StringMapMessage(QObject *parent = nullptr);
    ~SimpleSFixed64StringMapMessage() override;
    SimpleSFixed64StringMapMessage(const SimpleSFixed64StringMapMessage &other);
    SimpleSFixed64StringMapMessage &operator =(const SimpleSFixed64StringMapMessage &other);
    SimpleSFixed64StringMapMessage(SimpleSFixed64StringMapMessage &&other) noexcept;
    SimpleSFixed64StringMapMessage &operator =(SimpleSFixed64StringMapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed64StringMapMessage &other) const;
    bool operator !=(const SimpleSFixed64StringMapMessage &other) const;

    SimpleSFixed64StringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed64StringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed64StringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed64StringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleStringStringMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleStringStringMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 13,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QString, QString>;
    SimpleStringStringMapMessage(QObject *parent = nullptr);
    ~SimpleStringStringMapMessage() override;
    SimpleStringStringMapMessage(const SimpleStringStringMapMessage &other);
    SimpleStringStringMapMessage &operator =(const SimpleStringStringMapMessage &other);
    SimpleStringStringMapMessage(SimpleStringStringMapMessage &&other) noexcept;
    SimpleStringStringMapMessage &operator =(SimpleStringStringMapMessage &&other) noexcept;
    bool operator ==(const SimpleStringStringMapMessage &other) const;
    bool operator !=(const SimpleStringStringMapMessage &other) const;

    SimpleStringStringMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleStringStringMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleStringStringMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleStringStringMapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt32SInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt32SInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 1,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint32, QtProtobuf::sint32>;
    SimpleSInt32SInt32MapMessage(QObject *parent = nullptr);
    ~SimpleSInt32SInt32MapMessage() override;
    SimpleSInt32SInt32MapMessage(const SimpleSInt32SInt32MapMessage &other);
    SimpleSInt32SInt32MapMessage &operator =(const SimpleSInt32SInt32MapMessage &other);
    SimpleSInt32SInt32MapMessage(SimpleSInt32SInt32MapMessage &&other) noexcept;
    SimpleSInt32SInt32MapMessage &operator =(SimpleSInt32SInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt32SInt32MapMessage &other) const;
    bool operator !=(const SimpleSInt32SInt32MapMessage &other) const;

    SimpleSInt32SInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt32SInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt32SInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt32SInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt64SInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt64SInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 2,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint64, QtProtobuf::sint32>;
    SimpleSInt64SInt32MapMessage(QObject *parent = nullptr);
    ~SimpleSInt64SInt32MapMessage() override;
    SimpleSInt64SInt32MapMessage(const SimpleSInt64SInt32MapMessage &other);
    SimpleSInt64SInt32MapMessage &operator =(const SimpleSInt64SInt32MapMessage &other);
    SimpleSInt64SInt32MapMessage(SimpleSInt64SInt32MapMessage &&other) noexcept;
    SimpleSInt64SInt32MapMessage &operator =(SimpleSInt64SInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt64SInt32MapMessage &other) const;
    bool operator !=(const SimpleSInt64SInt32MapMessage &other) const;

    SimpleSInt64SInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt64SInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt64SInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt64SInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt32SInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt32SInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 3,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int32, QtProtobuf::sint32>;
    SimpleInt32SInt32MapMessage(QObject *parent = nullptr);
    ~SimpleInt32SInt32MapMessage() override;
    SimpleInt32SInt32MapMessage(const SimpleInt32SInt32MapMessage &other);
    SimpleInt32SInt32MapMessage &operator =(const SimpleInt32SInt32MapMessage &other);
    SimpleInt32SInt32MapMessage(SimpleInt32SInt32MapMessage &&other) noexcept;
    SimpleInt32SInt32MapMessage &operator =(SimpleInt32SInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt32SInt32MapMessage &other) const;
    bool operator !=(const SimpleInt32SInt32MapMessage &other) const;

    SimpleInt32SInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt32SInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt32SInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt32SInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt64SInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt64SInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 4,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int64, QtProtobuf::sint32>;
    SimpleInt64SInt32MapMessage(QObject *parent = nullptr);
    ~SimpleInt64SInt32MapMessage() override;
    SimpleInt64SInt32MapMessage(const SimpleInt64SInt32MapMessage &other);
    SimpleInt64SInt32MapMessage &operator =(const SimpleInt64SInt32MapMessage &other);
    SimpleInt64SInt32MapMessage(SimpleInt64SInt32MapMessage &&other) noexcept;
    SimpleInt64SInt32MapMessage &operator =(SimpleInt64SInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt64SInt32MapMessage &other) const;
    bool operator !=(const SimpleInt64SInt32MapMessage &other) const;

    SimpleInt64SInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt64SInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt64SInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt64SInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt32SInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt32SInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 5,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint32, QtProtobuf::sint32>;
    SimpleUInt32SInt32MapMessage(QObject *parent = nullptr);
    ~SimpleUInt32SInt32MapMessage() override;
    SimpleUInt32SInt32MapMessage(const SimpleUInt32SInt32MapMessage &other);
    SimpleUInt32SInt32MapMessage &operator =(const SimpleUInt32SInt32MapMessage &other);
    SimpleUInt32SInt32MapMessage(SimpleUInt32SInt32MapMessage &&other) noexcept;
    SimpleUInt32SInt32MapMessage &operator =(SimpleUInt32SInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt32SInt32MapMessage &other) const;
    bool operator !=(const SimpleUInt32SInt32MapMessage &other) const;

    SimpleUInt32SInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt32SInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt32SInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt32SInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt64SInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt64SInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 6,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint64, QtProtobuf::sint32>;
    SimpleUInt64SInt32MapMessage(QObject *parent = nullptr);
    ~SimpleUInt64SInt32MapMessage() override;
    SimpleUInt64SInt32MapMessage(const SimpleUInt64SInt32MapMessage &other);
    SimpleUInt64SInt32MapMessage &operator =(const SimpleUInt64SInt32MapMessage &other);
    SimpleUInt64SInt32MapMessage(SimpleUInt64SInt32MapMessage &&other) noexcept;
    SimpleUInt64SInt32MapMessage &operator =(SimpleUInt64SInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt64SInt32MapMessage &other) const;
    bool operator !=(const SimpleUInt64SInt32MapMessage &other) const;

    SimpleUInt64SInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt64SInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt64SInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt64SInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed32SInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed32SInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 7,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed32, QtProtobuf::sint32>;
    SimpleFixed32SInt32MapMessage(QObject *parent = nullptr);
    ~SimpleFixed32SInt32MapMessage() override;
    SimpleFixed32SInt32MapMessage(const SimpleFixed32SInt32MapMessage &other);
    SimpleFixed32SInt32MapMessage &operator =(const SimpleFixed32SInt32MapMessage &other);
    SimpleFixed32SInt32MapMessage(SimpleFixed32SInt32MapMessage &&other) noexcept;
    SimpleFixed32SInt32MapMessage &operator =(SimpleFixed32SInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed32SInt32MapMessage &other) const;
    bool operator !=(const SimpleFixed32SInt32MapMessage &other) const;

    SimpleFixed32SInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed32SInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed32SInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed32SInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed64SInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed64SInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 8,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed64, QtProtobuf::sint32>;
    SimpleFixed64SInt32MapMessage(QObject *parent = nullptr);
    ~SimpleFixed64SInt32MapMessage() override;
    SimpleFixed64SInt32MapMessage(const SimpleFixed64SInt32MapMessage &other);
    SimpleFixed64SInt32MapMessage &operator =(const SimpleFixed64SInt32MapMessage &other);
    SimpleFixed64SInt32MapMessage(SimpleFixed64SInt32MapMessage &&other) noexcept;
    SimpleFixed64SInt32MapMessage &operator =(SimpleFixed64SInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed64SInt32MapMessage &other) const;
    bool operator !=(const SimpleFixed64SInt32MapMessage &other) const;

    SimpleFixed64SInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed64SInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed64SInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed64SInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed32SInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed32SInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 9,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed32, QtProtobuf::sint32>;
    SimpleSFixed32SInt32MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed32SInt32MapMessage() override;
    SimpleSFixed32SInt32MapMessage(const SimpleSFixed32SInt32MapMessage &other);
    SimpleSFixed32SInt32MapMessage &operator =(const SimpleSFixed32SInt32MapMessage &other);
    SimpleSFixed32SInt32MapMessage(SimpleSFixed32SInt32MapMessage &&other) noexcept;
    SimpleSFixed32SInt32MapMessage &operator =(SimpleSFixed32SInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed32SInt32MapMessage &other) const;
    bool operator !=(const SimpleSFixed32SInt32MapMessage &other) const;

    SimpleSFixed32SInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed32SInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed32SInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed32SInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed64SInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed64SInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 10,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed64, QtProtobuf::sint32>;
    SimpleSFixed64SInt32MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed64SInt32MapMessage() override;
    SimpleSFixed64SInt32MapMessage(const SimpleSFixed64SInt32MapMessage &other);
    SimpleSFixed64SInt32MapMessage &operator =(const SimpleSFixed64SInt32MapMessage &other);
    SimpleSFixed64SInt32MapMessage(SimpleSFixed64SInt32MapMessage &&other) noexcept;
    SimpleSFixed64SInt32MapMessage &operator =(SimpleSFixed64SInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed64SInt32MapMessage &other) const;
    bool operator !=(const SimpleSFixed64SInt32MapMessage &other) const;

    SimpleSFixed64SInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed64SInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed64SInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed64SInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleStringSInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleStringSInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 13,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QString, QtProtobuf::sint32>;
    SimpleStringSInt32MapMessage(QObject *parent = nullptr);
    ~SimpleStringSInt32MapMessage() override;
    SimpleStringSInt32MapMessage(const SimpleStringSInt32MapMessage &other);
    SimpleStringSInt32MapMessage &operator =(const SimpleStringSInt32MapMessage &other);
    SimpleStringSInt32MapMessage(SimpleStringSInt32MapMessage &&other) noexcept;
    SimpleStringSInt32MapMessage &operator =(SimpleStringSInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleStringSInt32MapMessage &other) const;
    bool operator !=(const SimpleStringSInt32MapMessage &other) const;

    SimpleStringSInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleStringSInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleStringSInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleStringSInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt32SInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt32SInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 1,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint32, QtProtobuf::sint64>;
    SimpleSInt32SInt64MapMessage(QObject *parent = nullptr);
    ~SimpleSInt32SInt64MapMessage() override;
    SimpleSInt32SInt64MapMessage(const SimpleSInt32SInt64MapMessage &other);
    SimpleSInt32SInt64MapMessage &operator =(const SimpleSInt32SInt64MapMessage &other);
    SimpleSInt32SInt64MapMessage(SimpleSInt32SInt64MapMessage &&other) noexcept;
    SimpleSInt32SInt64MapMessage &operator =(SimpleSInt32SInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt32SInt64MapMessage &other) const;
    bool operator !=(const SimpleSInt32SInt64MapMessage &other) const;

    SimpleSInt32SInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt32SInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt32SInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt32SInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt64SInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt64SInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 2,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint64, QtProtobuf::sint64>;
    SimpleSInt64SInt64MapMessage(QObject *parent = nullptr);
    ~SimpleSInt64SInt64MapMessage() override;
    SimpleSInt64SInt64MapMessage(const SimpleSInt64SInt64MapMessage &other);
    SimpleSInt64SInt64MapMessage &operator =(const SimpleSInt64SInt64MapMessage &other);
    SimpleSInt64SInt64MapMessage(SimpleSInt64SInt64MapMessage &&other) noexcept;
    SimpleSInt64SInt64MapMessage &operator =(SimpleSInt64SInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt64SInt64MapMessage &other) const;
    bool operator !=(const SimpleSInt64SInt64MapMessage &other) const;

    SimpleSInt64SInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt64SInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt64SInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt64SInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt32SInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt32SInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 3,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int32, QtProtobuf::sint64>;
    SimpleInt32SInt64MapMessage(QObject *parent = nullptr);
    ~SimpleInt32SInt64MapMessage() override;
    SimpleInt32SInt64MapMessage(const SimpleInt32SInt64MapMessage &other);
    SimpleInt32SInt64MapMessage &operator =(const SimpleInt32SInt64MapMessage &other);
    SimpleInt32SInt64MapMessage(SimpleInt32SInt64MapMessage &&other) noexcept;
    SimpleInt32SInt64MapMessage &operator =(SimpleInt32SInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt32SInt64MapMessage &other) const;
    bool operator !=(const SimpleInt32SInt64MapMessage &other) const;

    SimpleInt32SInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt32SInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt32SInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt32SInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt64SInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt64SInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 4,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int64, QtProtobuf::sint64>;
    SimpleInt64SInt64MapMessage(QObject *parent = nullptr);
    ~SimpleInt64SInt64MapMessage() override;
    SimpleInt64SInt64MapMessage(const SimpleInt64SInt64MapMessage &other);
    SimpleInt64SInt64MapMessage &operator =(const SimpleInt64SInt64MapMessage &other);
    SimpleInt64SInt64MapMessage(SimpleInt64SInt64MapMessage &&other) noexcept;
    SimpleInt64SInt64MapMessage &operator =(SimpleInt64SInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt64SInt64MapMessage &other) const;
    bool operator !=(const SimpleInt64SInt64MapMessage &other) const;

    SimpleInt64SInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt64SInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt64SInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt64SInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt32SInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt32SInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 5,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint32, QtProtobuf::sint64>;
    SimpleUInt32SInt64MapMessage(QObject *parent = nullptr);
    ~SimpleUInt32SInt64MapMessage() override;
    SimpleUInt32SInt64MapMessage(const SimpleUInt32SInt64MapMessage &other);
    SimpleUInt32SInt64MapMessage &operator =(const SimpleUInt32SInt64MapMessage &other);
    SimpleUInt32SInt64MapMessage(SimpleUInt32SInt64MapMessage &&other) noexcept;
    SimpleUInt32SInt64MapMessage &operator =(SimpleUInt32SInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt32SInt64MapMessage &other) const;
    bool operator !=(const SimpleUInt32SInt64MapMessage &other) const;

    SimpleUInt32SInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt32SInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt32SInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt32SInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt64SInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt64SInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 6,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint64, QtProtobuf::sint64>;
    SimpleUInt64SInt64MapMessage(QObject *parent = nullptr);
    ~SimpleUInt64SInt64MapMessage() override;
    SimpleUInt64SInt64MapMessage(const SimpleUInt64SInt64MapMessage &other);
    SimpleUInt64SInt64MapMessage &operator =(const SimpleUInt64SInt64MapMessage &other);
    SimpleUInt64SInt64MapMessage(SimpleUInt64SInt64MapMessage &&other) noexcept;
    SimpleUInt64SInt64MapMessage &operator =(SimpleUInt64SInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt64SInt64MapMessage &other) const;
    bool operator !=(const SimpleUInt64SInt64MapMessage &other) const;

    SimpleUInt64SInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt64SInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt64SInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt64SInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed32SInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed32SInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 7,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed32, QtProtobuf::sint64>;
    SimpleFixed32SInt64MapMessage(QObject *parent = nullptr);
    ~SimpleFixed32SInt64MapMessage() override;
    SimpleFixed32SInt64MapMessage(const SimpleFixed32SInt64MapMessage &other);
    SimpleFixed32SInt64MapMessage &operator =(const SimpleFixed32SInt64MapMessage &other);
    SimpleFixed32SInt64MapMessage(SimpleFixed32SInt64MapMessage &&other) noexcept;
    SimpleFixed32SInt64MapMessage &operator =(SimpleFixed32SInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed32SInt64MapMessage &other) const;
    bool operator !=(const SimpleFixed32SInt64MapMessage &other) const;

    SimpleFixed32SInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed32SInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed32SInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed32SInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed64SInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed64SInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 8,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed64, QtProtobuf::sint64>;
    SimpleFixed64SInt64MapMessage(QObject *parent = nullptr);
    ~SimpleFixed64SInt64MapMessage() override;
    SimpleFixed64SInt64MapMessage(const SimpleFixed64SInt64MapMessage &other);
    SimpleFixed64SInt64MapMessage &operator =(const SimpleFixed64SInt64MapMessage &other);
    SimpleFixed64SInt64MapMessage(SimpleFixed64SInt64MapMessage &&other) noexcept;
    SimpleFixed64SInt64MapMessage &operator =(SimpleFixed64SInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed64SInt64MapMessage &other) const;
    bool operator !=(const SimpleFixed64SInt64MapMessage &other) const;

    SimpleFixed64SInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed64SInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed64SInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed64SInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed32SInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed32SInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 9,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed32, QtProtobuf::sint64>;
    SimpleSFixed32SInt64MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed32SInt64MapMessage() override;
    SimpleSFixed32SInt64MapMessage(const SimpleSFixed32SInt64MapMessage &other);
    SimpleSFixed32SInt64MapMessage &operator =(const SimpleSFixed32SInt64MapMessage &other);
    SimpleSFixed32SInt64MapMessage(SimpleSFixed32SInt64MapMessage &&other) noexcept;
    SimpleSFixed32SInt64MapMessage &operator =(SimpleSFixed32SInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed32SInt64MapMessage &other) const;
    bool operator !=(const SimpleSFixed32SInt64MapMessage &other) const;

    SimpleSFixed32SInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed32SInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed32SInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed32SInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed64SInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed64SInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 10,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed64, QtProtobuf::sint64>;
    SimpleSFixed64SInt64MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed64SInt64MapMessage() override;
    SimpleSFixed64SInt64MapMessage(const SimpleSFixed64SInt64MapMessage &other);
    SimpleSFixed64SInt64MapMessage &operator =(const SimpleSFixed64SInt64MapMessage &other);
    SimpleSFixed64SInt64MapMessage(SimpleSFixed64SInt64MapMessage &&other) noexcept;
    SimpleSFixed64SInt64MapMessage &operator =(SimpleSFixed64SInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed64SInt64MapMessage &other) const;
    bool operator !=(const SimpleSFixed64SInt64MapMessage &other) const;

    SimpleSFixed64SInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed64SInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed64SInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed64SInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleStringSInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleStringSInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 13,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QString, QtProtobuf::sint64>;
    SimpleStringSInt64MapMessage(QObject *parent = nullptr);
    ~SimpleStringSInt64MapMessage() override;
    SimpleStringSInt64MapMessage(const SimpleStringSInt64MapMessage &other);
    SimpleStringSInt64MapMessage &operator =(const SimpleStringSInt64MapMessage &other);
    SimpleStringSInt64MapMessage(SimpleStringSInt64MapMessage &&other) noexcept;
    SimpleStringSInt64MapMessage &operator =(SimpleStringSInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleStringSInt64MapMessage &other) const;
    bool operator !=(const SimpleStringSInt64MapMessage &other) const;

    SimpleStringSInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleStringSInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleStringSInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleStringSInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt32UInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt32UInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 1,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint32, QtProtobuf::uint32>;
    SimpleSInt32UInt32MapMessage(QObject *parent = nullptr);
    ~SimpleSInt32UInt32MapMessage() override;
    SimpleSInt32UInt32MapMessage(const SimpleSInt32UInt32MapMessage &other);
    SimpleSInt32UInt32MapMessage &operator =(const SimpleSInt32UInt32MapMessage &other);
    SimpleSInt32UInt32MapMessage(SimpleSInt32UInt32MapMessage &&other) noexcept;
    SimpleSInt32UInt32MapMessage &operator =(SimpleSInt32UInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt32UInt32MapMessage &other) const;
    bool operator !=(const SimpleSInt32UInt32MapMessage &other) const;

    SimpleSInt32UInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt32UInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt32UInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt32UInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt64UInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt64UInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 2,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint64, QtProtobuf::uint32>;
    SimpleSInt64UInt32MapMessage(QObject *parent = nullptr);
    ~SimpleSInt64UInt32MapMessage() override;
    SimpleSInt64UInt32MapMessage(const SimpleSInt64UInt32MapMessage &other);
    SimpleSInt64UInt32MapMessage &operator =(const SimpleSInt64UInt32MapMessage &other);
    SimpleSInt64UInt32MapMessage(SimpleSInt64UInt32MapMessage &&other) noexcept;
    SimpleSInt64UInt32MapMessage &operator =(SimpleSInt64UInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt64UInt32MapMessage &other) const;
    bool operator !=(const SimpleSInt64UInt32MapMessage &other) const;

    SimpleSInt64UInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt64UInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt64UInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt64UInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt32UInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt32UInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 3,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int32, QtProtobuf::uint32>;
    SimpleInt32UInt32MapMessage(QObject *parent = nullptr);
    ~SimpleInt32UInt32MapMessage() override;
    SimpleInt32UInt32MapMessage(const SimpleInt32UInt32MapMessage &other);
    SimpleInt32UInt32MapMessage &operator =(const SimpleInt32UInt32MapMessage &other);
    SimpleInt32UInt32MapMessage(SimpleInt32UInt32MapMessage &&other) noexcept;
    SimpleInt32UInt32MapMessage &operator =(SimpleInt32UInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt32UInt32MapMessage &other) const;
    bool operator !=(const SimpleInt32UInt32MapMessage &other) const;

    SimpleInt32UInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt32UInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt32UInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt32UInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt64UInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt64UInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 4,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int64, QtProtobuf::uint32>;
    SimpleInt64UInt32MapMessage(QObject *parent = nullptr);
    ~SimpleInt64UInt32MapMessage() override;
    SimpleInt64UInt32MapMessage(const SimpleInt64UInt32MapMessage &other);
    SimpleInt64UInt32MapMessage &operator =(const SimpleInt64UInt32MapMessage &other);
    SimpleInt64UInt32MapMessage(SimpleInt64UInt32MapMessage &&other) noexcept;
    SimpleInt64UInt32MapMessage &operator =(SimpleInt64UInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt64UInt32MapMessage &other) const;
    bool operator !=(const SimpleInt64UInt32MapMessage &other) const;

    SimpleInt64UInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt64UInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt64UInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt64UInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt32UInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt32UInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 5,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint32, QtProtobuf::uint32>;
    SimpleUInt32UInt32MapMessage(QObject *parent = nullptr);
    ~SimpleUInt32UInt32MapMessage() override;
    SimpleUInt32UInt32MapMessage(const SimpleUInt32UInt32MapMessage &other);
    SimpleUInt32UInt32MapMessage &operator =(const SimpleUInt32UInt32MapMessage &other);
    SimpleUInt32UInt32MapMessage(SimpleUInt32UInt32MapMessage &&other) noexcept;
    SimpleUInt32UInt32MapMessage &operator =(SimpleUInt32UInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt32UInt32MapMessage &other) const;
    bool operator !=(const SimpleUInt32UInt32MapMessage &other) const;

    SimpleUInt32UInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt32UInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt32UInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt32UInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt64UInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt64UInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 6,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint64, QtProtobuf::uint32>;
    SimpleUInt64UInt32MapMessage(QObject *parent = nullptr);
    ~SimpleUInt64UInt32MapMessage() override;
    SimpleUInt64UInt32MapMessage(const SimpleUInt64UInt32MapMessage &other);
    SimpleUInt64UInt32MapMessage &operator =(const SimpleUInt64UInt32MapMessage &other);
    SimpleUInt64UInt32MapMessage(SimpleUInt64UInt32MapMessage &&other) noexcept;
    SimpleUInt64UInt32MapMessage &operator =(SimpleUInt64UInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt64UInt32MapMessage &other) const;
    bool operator !=(const SimpleUInt64UInt32MapMessage &other) const;

    SimpleUInt64UInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt64UInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt64UInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt64UInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed32UInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed32UInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 7,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed32, QtProtobuf::uint32>;
    SimpleFixed32UInt32MapMessage(QObject *parent = nullptr);
    ~SimpleFixed32UInt32MapMessage() override;
    SimpleFixed32UInt32MapMessage(const SimpleFixed32UInt32MapMessage &other);
    SimpleFixed32UInt32MapMessage &operator =(const SimpleFixed32UInt32MapMessage &other);
    SimpleFixed32UInt32MapMessage(SimpleFixed32UInt32MapMessage &&other) noexcept;
    SimpleFixed32UInt32MapMessage &operator =(SimpleFixed32UInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed32UInt32MapMessage &other) const;
    bool operator !=(const SimpleFixed32UInt32MapMessage &other) const;

    SimpleFixed32UInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed32UInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed32UInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed32UInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed64UInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed64UInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 8,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed64, QtProtobuf::uint32>;
    SimpleFixed64UInt32MapMessage(QObject *parent = nullptr);
    ~SimpleFixed64UInt32MapMessage() override;
    SimpleFixed64UInt32MapMessage(const SimpleFixed64UInt32MapMessage &other);
    SimpleFixed64UInt32MapMessage &operator =(const SimpleFixed64UInt32MapMessage &other);
    SimpleFixed64UInt32MapMessage(SimpleFixed64UInt32MapMessage &&other) noexcept;
    SimpleFixed64UInt32MapMessage &operator =(SimpleFixed64UInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed64UInt32MapMessage &other) const;
    bool operator !=(const SimpleFixed64UInt32MapMessage &other) const;

    SimpleFixed64UInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed64UInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed64UInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed64UInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed32UInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed32UInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 9,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed32, QtProtobuf::uint32>;
    SimpleSFixed32UInt32MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed32UInt32MapMessage() override;
    SimpleSFixed32UInt32MapMessage(const SimpleSFixed32UInt32MapMessage &other);
    SimpleSFixed32UInt32MapMessage &operator =(const SimpleSFixed32UInt32MapMessage &other);
    SimpleSFixed32UInt32MapMessage(SimpleSFixed32UInt32MapMessage &&other) noexcept;
    SimpleSFixed32UInt32MapMessage &operator =(SimpleSFixed32UInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed32UInt32MapMessage &other) const;
    bool operator !=(const SimpleSFixed32UInt32MapMessage &other) const;

    SimpleSFixed32UInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed32UInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed32UInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed32UInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed64UInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed64UInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 10,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed64, QtProtobuf::uint32>;
    SimpleSFixed64UInt32MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed64UInt32MapMessage() override;
    SimpleSFixed64UInt32MapMessage(const SimpleSFixed64UInt32MapMessage &other);
    SimpleSFixed64UInt32MapMessage &operator =(const SimpleSFixed64UInt32MapMessage &other);
    SimpleSFixed64UInt32MapMessage(SimpleSFixed64UInt32MapMessage &&other) noexcept;
    SimpleSFixed64UInt32MapMessage &operator =(SimpleSFixed64UInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed64UInt32MapMessage &other) const;
    bool operator !=(const SimpleSFixed64UInt32MapMessage &other) const;

    SimpleSFixed64UInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed64UInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed64UInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed64UInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleStringUInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleStringUInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 13,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QString, QtProtobuf::uint32>;
    SimpleStringUInt32MapMessage(QObject *parent = nullptr);
    ~SimpleStringUInt32MapMessage() override;
    SimpleStringUInt32MapMessage(const SimpleStringUInt32MapMessage &other);
    SimpleStringUInt32MapMessage &operator =(const SimpleStringUInt32MapMessage &other);
    SimpleStringUInt32MapMessage(SimpleStringUInt32MapMessage &&other) noexcept;
    SimpleStringUInt32MapMessage &operator =(SimpleStringUInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleStringUInt32MapMessage &other) const;
    bool operator !=(const SimpleStringUInt32MapMessage &other) const;

    SimpleStringUInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleStringUInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleStringUInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleStringUInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt32UInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt32UInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 1,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint32, QtProtobuf::uint64>;
    SimpleSInt32UInt64MapMessage(QObject *parent = nullptr);
    ~SimpleSInt32UInt64MapMessage() override;
    SimpleSInt32UInt64MapMessage(const SimpleSInt32UInt64MapMessage &other);
    SimpleSInt32UInt64MapMessage &operator =(const SimpleSInt32UInt64MapMessage &other);
    SimpleSInt32UInt64MapMessage(SimpleSInt32UInt64MapMessage &&other) noexcept;
    SimpleSInt32UInt64MapMessage &operator =(SimpleSInt32UInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt32UInt64MapMessage &other) const;
    bool operator !=(const SimpleSInt32UInt64MapMessage &other) const;

    SimpleSInt32UInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt32UInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt32UInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt32UInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt64UInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt64UInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 2,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint64, QtProtobuf::uint64>;
    SimpleSInt64UInt64MapMessage(QObject *parent = nullptr);
    ~SimpleSInt64UInt64MapMessage() override;
    SimpleSInt64UInt64MapMessage(const SimpleSInt64UInt64MapMessage &other);
    SimpleSInt64UInt64MapMessage &operator =(const SimpleSInt64UInt64MapMessage &other);
    SimpleSInt64UInt64MapMessage(SimpleSInt64UInt64MapMessage &&other) noexcept;
    SimpleSInt64UInt64MapMessage &operator =(SimpleSInt64UInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt64UInt64MapMessage &other) const;
    bool operator !=(const SimpleSInt64UInt64MapMessage &other) const;

    SimpleSInt64UInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt64UInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt64UInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt64UInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt32UInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt32UInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 3,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int32, QtProtobuf::uint64>;
    SimpleInt32UInt64MapMessage(QObject *parent = nullptr);
    ~SimpleInt32UInt64MapMessage() override;
    SimpleInt32UInt64MapMessage(const SimpleInt32UInt64MapMessage &other);
    SimpleInt32UInt64MapMessage &operator =(const SimpleInt32UInt64MapMessage &other);
    SimpleInt32UInt64MapMessage(SimpleInt32UInt64MapMessage &&other) noexcept;
    SimpleInt32UInt64MapMessage &operator =(SimpleInt32UInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt32UInt64MapMessage &other) const;
    bool operator !=(const SimpleInt32UInt64MapMessage &other) const;

    SimpleInt32UInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt32UInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt32UInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt32UInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt64UInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt64UInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 4,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int64, QtProtobuf::uint64>;
    SimpleInt64UInt64MapMessage(QObject *parent = nullptr);
    ~SimpleInt64UInt64MapMessage() override;
    SimpleInt64UInt64MapMessage(const SimpleInt64UInt64MapMessage &other);
    SimpleInt64UInt64MapMessage &operator =(const SimpleInt64UInt64MapMessage &other);
    SimpleInt64UInt64MapMessage(SimpleInt64UInt64MapMessage &&other) noexcept;
    SimpleInt64UInt64MapMessage &operator =(SimpleInt64UInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt64UInt64MapMessage &other) const;
    bool operator !=(const SimpleInt64UInt64MapMessage &other) const;

    SimpleInt64UInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt64UInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt64UInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt64UInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt32UInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt32UInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 5,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint32, QtProtobuf::uint64>;
    SimpleUInt32UInt64MapMessage(QObject *parent = nullptr);
    ~SimpleUInt32UInt64MapMessage() override;
    SimpleUInt32UInt64MapMessage(const SimpleUInt32UInt64MapMessage &other);
    SimpleUInt32UInt64MapMessage &operator =(const SimpleUInt32UInt64MapMessage &other);
    SimpleUInt32UInt64MapMessage(SimpleUInt32UInt64MapMessage &&other) noexcept;
    SimpleUInt32UInt64MapMessage &operator =(SimpleUInt32UInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt32UInt64MapMessage &other) const;
    bool operator !=(const SimpleUInt32UInt64MapMessage &other) const;

    SimpleUInt32UInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt32UInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt32UInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt32UInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt64UInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt64UInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 6,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint64, QtProtobuf::uint64>;
    SimpleUInt64UInt64MapMessage(QObject *parent = nullptr);
    ~SimpleUInt64UInt64MapMessage() override;
    SimpleUInt64UInt64MapMessage(const SimpleUInt64UInt64MapMessage &other);
    SimpleUInt64UInt64MapMessage &operator =(const SimpleUInt64UInt64MapMessage &other);
    SimpleUInt64UInt64MapMessage(SimpleUInt64UInt64MapMessage &&other) noexcept;
    SimpleUInt64UInt64MapMessage &operator =(SimpleUInt64UInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt64UInt64MapMessage &other) const;
    bool operator !=(const SimpleUInt64UInt64MapMessage &other) const;

    SimpleUInt64UInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt64UInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt64UInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt64UInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed32UInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed32UInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 7,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed32, QtProtobuf::uint64>;
    SimpleFixed32UInt64MapMessage(QObject *parent = nullptr);
    ~SimpleFixed32UInt64MapMessage() override;
    SimpleFixed32UInt64MapMessage(const SimpleFixed32UInt64MapMessage &other);
    SimpleFixed32UInt64MapMessage &operator =(const SimpleFixed32UInt64MapMessage &other);
    SimpleFixed32UInt64MapMessage(SimpleFixed32UInt64MapMessage &&other) noexcept;
    SimpleFixed32UInt64MapMessage &operator =(SimpleFixed32UInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed32UInt64MapMessage &other) const;
    bool operator !=(const SimpleFixed32UInt64MapMessage &other) const;

    SimpleFixed32UInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed32UInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed32UInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed32UInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed64UInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed64UInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 8,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed64, QtProtobuf::uint64>;
    SimpleFixed64UInt64MapMessage(QObject *parent = nullptr);
    ~SimpleFixed64UInt64MapMessage() override;
    SimpleFixed64UInt64MapMessage(const SimpleFixed64UInt64MapMessage &other);
    SimpleFixed64UInt64MapMessage &operator =(const SimpleFixed64UInt64MapMessage &other);
    SimpleFixed64UInt64MapMessage(SimpleFixed64UInt64MapMessage &&other) noexcept;
    SimpleFixed64UInt64MapMessage &operator =(SimpleFixed64UInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed64UInt64MapMessage &other) const;
    bool operator !=(const SimpleFixed64UInt64MapMessage &other) const;

    SimpleFixed64UInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed64UInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed64UInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed64UInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed32UInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed32UInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 9,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed32, QtProtobuf::uint64>;
    SimpleSFixed32UInt64MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed32UInt64MapMessage() override;
    SimpleSFixed32UInt64MapMessage(const SimpleSFixed32UInt64MapMessage &other);
    SimpleSFixed32UInt64MapMessage &operator =(const SimpleSFixed32UInt64MapMessage &other);
    SimpleSFixed32UInt64MapMessage(SimpleSFixed32UInt64MapMessage &&other) noexcept;
    SimpleSFixed32UInt64MapMessage &operator =(SimpleSFixed32UInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed32UInt64MapMessage &other) const;
    bool operator !=(const SimpleSFixed32UInt64MapMessage &other) const;

    SimpleSFixed32UInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed32UInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed32UInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed32UInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed64UInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed64UInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 10,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed64, QtProtobuf::uint64>;
    SimpleSFixed64UInt64MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed64UInt64MapMessage() override;
    SimpleSFixed64UInt64MapMessage(const SimpleSFixed64UInt64MapMessage &other);
    SimpleSFixed64UInt64MapMessage &operator =(const SimpleSFixed64UInt64MapMessage &other);
    SimpleSFixed64UInt64MapMessage(SimpleSFixed64UInt64MapMessage &&other) noexcept;
    SimpleSFixed64UInt64MapMessage &operator =(SimpleSFixed64UInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed64UInt64MapMessage &other) const;
    bool operator !=(const SimpleSFixed64UInt64MapMessage &other) const;

    SimpleSFixed64UInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed64UInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed64UInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed64UInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleStringUInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleStringUInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 13,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QString, QtProtobuf::uint64>;
    SimpleStringUInt64MapMessage(QObject *parent = nullptr);
    ~SimpleStringUInt64MapMessage() override;
    SimpleStringUInt64MapMessage(const SimpleStringUInt64MapMessage &other);
    SimpleStringUInt64MapMessage &operator =(const SimpleStringUInt64MapMessage &other);
    SimpleStringUInt64MapMessage(SimpleStringUInt64MapMessage &&other) noexcept;
    SimpleStringUInt64MapMessage &operator =(SimpleStringUInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleStringUInt64MapMessage &other) const;
    bool operator !=(const SimpleStringUInt64MapMessage &other) const;

    SimpleStringUInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleStringUInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleStringUInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleStringUInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt32Int32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt32Int32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 1,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint32, QtProtobuf::int32>;
    SimpleSInt32Int32MapMessage(QObject *parent = nullptr);
    ~SimpleSInt32Int32MapMessage() override;
    SimpleSInt32Int32MapMessage(const SimpleSInt32Int32MapMessage &other);
    SimpleSInt32Int32MapMessage &operator =(const SimpleSInt32Int32MapMessage &other);
    SimpleSInt32Int32MapMessage(SimpleSInt32Int32MapMessage &&other) noexcept;
    SimpleSInt32Int32MapMessage &operator =(SimpleSInt32Int32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt32Int32MapMessage &other) const;
    bool operator !=(const SimpleSInt32Int32MapMessage &other) const;

    SimpleSInt32Int32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt32Int32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt32Int32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt32Int32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt64Int32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt64Int32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 2,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint64, QtProtobuf::int32>;
    SimpleSInt64Int32MapMessage(QObject *parent = nullptr);
    ~SimpleSInt64Int32MapMessage() override;
    SimpleSInt64Int32MapMessage(const SimpleSInt64Int32MapMessage &other);
    SimpleSInt64Int32MapMessage &operator =(const SimpleSInt64Int32MapMessage &other);
    SimpleSInt64Int32MapMessage(SimpleSInt64Int32MapMessage &&other) noexcept;
    SimpleSInt64Int32MapMessage &operator =(SimpleSInt64Int32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt64Int32MapMessage &other) const;
    bool operator !=(const SimpleSInt64Int32MapMessage &other) const;

    SimpleSInt64Int32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt64Int32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt64Int32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt64Int32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt32Int32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt32Int32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 3,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int32, QtProtobuf::int32>;
    SimpleInt32Int32MapMessage(QObject *parent = nullptr);
    ~SimpleInt32Int32MapMessage() override;
    SimpleInt32Int32MapMessage(const SimpleInt32Int32MapMessage &other);
    SimpleInt32Int32MapMessage &operator =(const SimpleInt32Int32MapMessage &other);
    SimpleInt32Int32MapMessage(SimpleInt32Int32MapMessage &&other) noexcept;
    SimpleInt32Int32MapMessage &operator =(SimpleInt32Int32MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt32Int32MapMessage &other) const;
    bool operator !=(const SimpleInt32Int32MapMessage &other) const;

    SimpleInt32Int32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt32Int32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt32Int32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt32Int32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt64Int32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt64Int32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 4,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int64, QtProtobuf::int32>;
    SimpleInt64Int32MapMessage(QObject *parent = nullptr);
    ~SimpleInt64Int32MapMessage() override;
    SimpleInt64Int32MapMessage(const SimpleInt64Int32MapMessage &other);
    SimpleInt64Int32MapMessage &operator =(const SimpleInt64Int32MapMessage &other);
    SimpleInt64Int32MapMessage(SimpleInt64Int32MapMessage &&other) noexcept;
    SimpleInt64Int32MapMessage &operator =(SimpleInt64Int32MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt64Int32MapMessage &other) const;
    bool operator !=(const SimpleInt64Int32MapMessage &other) const;

    SimpleInt64Int32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt64Int32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt64Int32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt64Int32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt32Int32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt32Int32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 5,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint32, QtProtobuf::int32>;
    SimpleUInt32Int32MapMessage(QObject *parent = nullptr);
    ~SimpleUInt32Int32MapMessage() override;
    SimpleUInt32Int32MapMessage(const SimpleUInt32Int32MapMessage &other);
    SimpleUInt32Int32MapMessage &operator =(const SimpleUInt32Int32MapMessage &other);
    SimpleUInt32Int32MapMessage(SimpleUInt32Int32MapMessage &&other) noexcept;
    SimpleUInt32Int32MapMessage &operator =(SimpleUInt32Int32MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt32Int32MapMessage &other) const;
    bool operator !=(const SimpleUInt32Int32MapMessage &other) const;

    SimpleUInt32Int32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt32Int32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt32Int32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt32Int32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt64Int32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt64Int32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 6,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint64, QtProtobuf::int32>;
    SimpleUInt64Int32MapMessage(QObject *parent = nullptr);
    ~SimpleUInt64Int32MapMessage() override;
    SimpleUInt64Int32MapMessage(const SimpleUInt64Int32MapMessage &other);
    SimpleUInt64Int32MapMessage &operator =(const SimpleUInt64Int32MapMessage &other);
    SimpleUInt64Int32MapMessage(SimpleUInt64Int32MapMessage &&other) noexcept;
    SimpleUInt64Int32MapMessage &operator =(SimpleUInt64Int32MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt64Int32MapMessage &other) const;
    bool operator !=(const SimpleUInt64Int32MapMessage &other) const;

    SimpleUInt64Int32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt64Int32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt64Int32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt64Int32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed32Int32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed32Int32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 7,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed32, QtProtobuf::int32>;
    SimpleFixed32Int32MapMessage(QObject *parent = nullptr);
    ~SimpleFixed32Int32MapMessage() override;
    SimpleFixed32Int32MapMessage(const SimpleFixed32Int32MapMessage &other);
    SimpleFixed32Int32MapMessage &operator =(const SimpleFixed32Int32MapMessage &other);
    SimpleFixed32Int32MapMessage(SimpleFixed32Int32MapMessage &&other) noexcept;
    SimpleFixed32Int32MapMessage &operator =(SimpleFixed32Int32MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed32Int32MapMessage &other) const;
    bool operator !=(const SimpleFixed32Int32MapMessage &other) const;

    SimpleFixed32Int32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed32Int32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed32Int32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed32Int32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed64Int32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed64Int32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 8,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed64, QtProtobuf::int32>;
    SimpleFixed64Int32MapMessage(QObject *parent = nullptr);
    ~SimpleFixed64Int32MapMessage() override;
    SimpleFixed64Int32MapMessage(const SimpleFixed64Int32MapMessage &other);
    SimpleFixed64Int32MapMessage &operator =(const SimpleFixed64Int32MapMessage &other);
    SimpleFixed64Int32MapMessage(SimpleFixed64Int32MapMessage &&other) noexcept;
    SimpleFixed64Int32MapMessage &operator =(SimpleFixed64Int32MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed64Int32MapMessage &other) const;
    bool operator !=(const SimpleFixed64Int32MapMessage &other) const;

    SimpleFixed64Int32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed64Int32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed64Int32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed64Int32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed32Int32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed32Int32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 9,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed32, QtProtobuf::int32>;
    SimpleSFixed32Int32MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed32Int32MapMessage() override;
    SimpleSFixed32Int32MapMessage(const SimpleSFixed32Int32MapMessage &other);
    SimpleSFixed32Int32MapMessage &operator =(const SimpleSFixed32Int32MapMessage &other);
    SimpleSFixed32Int32MapMessage(SimpleSFixed32Int32MapMessage &&other) noexcept;
    SimpleSFixed32Int32MapMessage &operator =(SimpleSFixed32Int32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed32Int32MapMessage &other) const;
    bool operator !=(const SimpleSFixed32Int32MapMessage &other) const;

    SimpleSFixed32Int32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed32Int32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed32Int32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed32Int32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed64Int32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed64Int32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 10,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed64, QtProtobuf::int32>;
    SimpleSFixed64Int32MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed64Int32MapMessage() override;
    SimpleSFixed64Int32MapMessage(const SimpleSFixed64Int32MapMessage &other);
    SimpleSFixed64Int32MapMessage &operator =(const SimpleSFixed64Int32MapMessage &other);
    SimpleSFixed64Int32MapMessage(SimpleSFixed64Int32MapMessage &&other) noexcept;
    SimpleSFixed64Int32MapMessage &operator =(SimpleSFixed64Int32MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed64Int32MapMessage &other) const;
    bool operator !=(const SimpleSFixed64Int32MapMessage &other) const;

    SimpleSFixed64Int32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed64Int32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed64Int32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed64Int32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleStringInt32MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleStringInt32MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 13,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QString, QtProtobuf::int32>;
    SimpleStringInt32MapMessage(QObject *parent = nullptr);
    ~SimpleStringInt32MapMessage() override;
    SimpleStringInt32MapMessage(const SimpleStringInt32MapMessage &other);
    SimpleStringInt32MapMessage &operator =(const SimpleStringInt32MapMessage &other);
    SimpleStringInt32MapMessage(SimpleStringInt32MapMessage &&other) noexcept;
    SimpleStringInt32MapMessage &operator =(SimpleStringInt32MapMessage &&other) noexcept;
    bool operator ==(const SimpleStringInt32MapMessage &other) const;
    bool operator !=(const SimpleStringInt32MapMessage &other) const;

    SimpleStringInt32MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleStringInt32MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleStringInt32MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleStringInt32MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt32Int64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt32Int64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 1,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint32, QtProtobuf::int64>;
    SimpleSInt32Int64MapMessage(QObject *parent = nullptr);
    ~SimpleSInt32Int64MapMessage() override;
    SimpleSInt32Int64MapMessage(const SimpleSInt32Int64MapMessage &other);
    SimpleSInt32Int64MapMessage &operator =(const SimpleSInt32Int64MapMessage &other);
    SimpleSInt32Int64MapMessage(SimpleSInt32Int64MapMessage &&other) noexcept;
    SimpleSInt32Int64MapMessage &operator =(SimpleSInt32Int64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt32Int64MapMessage &other) const;
    bool operator !=(const SimpleSInt32Int64MapMessage &other) const;

    SimpleSInt32Int64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt32Int64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt32Int64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt32Int64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt64Int64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt64Int64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 2,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint64, QtProtobuf::int64>;
    SimpleSInt64Int64MapMessage(QObject *parent = nullptr);
    ~SimpleSInt64Int64MapMessage() override;
    SimpleSInt64Int64MapMessage(const SimpleSInt64Int64MapMessage &other);
    SimpleSInt64Int64MapMessage &operator =(const SimpleSInt64Int64MapMessage &other);
    SimpleSInt64Int64MapMessage(SimpleSInt64Int64MapMessage &&other) noexcept;
    SimpleSInt64Int64MapMessage &operator =(SimpleSInt64Int64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt64Int64MapMessage &other) const;
    bool operator !=(const SimpleSInt64Int64MapMessage &other) const;

    SimpleSInt64Int64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt64Int64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt64Int64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt64Int64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt32Int64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt32Int64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 3,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int32, QtProtobuf::int64>;
    SimpleInt32Int64MapMessage(QObject *parent = nullptr);
    ~SimpleInt32Int64MapMessage() override;
    SimpleInt32Int64MapMessage(const SimpleInt32Int64MapMessage &other);
    SimpleInt32Int64MapMessage &operator =(const SimpleInt32Int64MapMessage &other);
    SimpleInt32Int64MapMessage(SimpleInt32Int64MapMessage &&other) noexcept;
    SimpleInt32Int64MapMessage &operator =(SimpleInt32Int64MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt32Int64MapMessage &other) const;
    bool operator !=(const SimpleInt32Int64MapMessage &other) const;

    SimpleInt32Int64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt32Int64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt32Int64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt32Int64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt64Int64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt64Int64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 4,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int64, QtProtobuf::int64>;
    SimpleInt64Int64MapMessage(QObject *parent = nullptr);
    ~SimpleInt64Int64MapMessage() override;
    SimpleInt64Int64MapMessage(const SimpleInt64Int64MapMessage &other);
    SimpleInt64Int64MapMessage &operator =(const SimpleInt64Int64MapMessage &other);
    SimpleInt64Int64MapMessage(SimpleInt64Int64MapMessage &&other) noexcept;
    SimpleInt64Int64MapMessage &operator =(SimpleInt64Int64MapMessage &&other) noexcept;
    bool operator ==(const SimpleInt64Int64MapMessage &other) const;
    bool operator !=(const SimpleInt64Int64MapMessage &other) const;

    SimpleInt64Int64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt64Int64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt64Int64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt64Int64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt32Int64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt32Int64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 5,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint32, QtProtobuf::int64>;
    SimpleUInt32Int64MapMessage(QObject *parent = nullptr);
    ~SimpleUInt32Int64MapMessage() override;
    SimpleUInt32Int64MapMessage(const SimpleUInt32Int64MapMessage &other);
    SimpleUInt32Int64MapMessage &operator =(const SimpleUInt32Int64MapMessage &other);
    SimpleUInt32Int64MapMessage(SimpleUInt32Int64MapMessage &&other) noexcept;
    SimpleUInt32Int64MapMessage &operator =(SimpleUInt32Int64MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt32Int64MapMessage &other) const;
    bool operator !=(const SimpleUInt32Int64MapMessage &other) const;

    SimpleUInt32Int64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt32Int64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt32Int64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt32Int64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt64Int64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt64Int64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 6,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint64, QtProtobuf::int64>;
    SimpleUInt64Int64MapMessage(QObject *parent = nullptr);
    ~SimpleUInt64Int64MapMessage() override;
    SimpleUInt64Int64MapMessage(const SimpleUInt64Int64MapMessage &other);
    SimpleUInt64Int64MapMessage &operator =(const SimpleUInt64Int64MapMessage &other);
    SimpleUInt64Int64MapMessage(SimpleUInt64Int64MapMessage &&other) noexcept;
    SimpleUInt64Int64MapMessage &operator =(SimpleUInt64Int64MapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt64Int64MapMessage &other) const;
    bool operator !=(const SimpleUInt64Int64MapMessage &other) const;

    SimpleUInt64Int64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt64Int64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt64Int64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt64Int64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed32Int64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed32Int64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 7,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed32, QtProtobuf::int64>;
    SimpleFixed32Int64MapMessage(QObject *parent = nullptr);
    ~SimpleFixed32Int64MapMessage() override;
    SimpleFixed32Int64MapMessage(const SimpleFixed32Int64MapMessage &other);
    SimpleFixed32Int64MapMessage &operator =(const SimpleFixed32Int64MapMessage &other);
    SimpleFixed32Int64MapMessage(SimpleFixed32Int64MapMessage &&other) noexcept;
    SimpleFixed32Int64MapMessage &operator =(SimpleFixed32Int64MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed32Int64MapMessage &other) const;
    bool operator !=(const SimpleFixed32Int64MapMessage &other) const;

    SimpleFixed32Int64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed32Int64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed32Int64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed32Int64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed64Int64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed64Int64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 8,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed64, QtProtobuf::int64>;
    SimpleFixed64Int64MapMessage(QObject *parent = nullptr);
    ~SimpleFixed64Int64MapMessage() override;
    SimpleFixed64Int64MapMessage(const SimpleFixed64Int64MapMessage &other);
    SimpleFixed64Int64MapMessage &operator =(const SimpleFixed64Int64MapMessage &other);
    SimpleFixed64Int64MapMessage(SimpleFixed64Int64MapMessage &&other) noexcept;
    SimpleFixed64Int64MapMessage &operator =(SimpleFixed64Int64MapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed64Int64MapMessage &other) const;
    bool operator !=(const SimpleFixed64Int64MapMessage &other) const;

    SimpleFixed64Int64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed64Int64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed64Int64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed64Int64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed32Int64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed32Int64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 9,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed32, QtProtobuf::int64>;
    SimpleSFixed32Int64MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed32Int64MapMessage() override;
    SimpleSFixed32Int64MapMessage(const SimpleSFixed32Int64MapMessage &other);
    SimpleSFixed32Int64MapMessage &operator =(const SimpleSFixed32Int64MapMessage &other);
    SimpleSFixed32Int64MapMessage(SimpleSFixed32Int64MapMessage &&other) noexcept;
    SimpleSFixed32Int64MapMessage &operator =(SimpleSFixed32Int64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed32Int64MapMessage &other) const;
    bool operator !=(const SimpleSFixed32Int64MapMessage &other) const;

    SimpleSFixed32Int64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed32Int64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed32Int64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed32Int64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed64Int64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed64Int64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 10,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed64, QtProtobuf::int64>;
    SimpleSFixed64Int64MapMessage(QObject *parent = nullptr);
    ~SimpleSFixed64Int64MapMessage() override;
    SimpleSFixed64Int64MapMessage(const SimpleSFixed64Int64MapMessage &other);
    SimpleSFixed64Int64MapMessage &operator =(const SimpleSFixed64Int64MapMessage &other);
    SimpleSFixed64Int64MapMessage(SimpleSFixed64Int64MapMessage &&other) noexcept;
    SimpleSFixed64Int64MapMessage &operator =(SimpleSFixed64Int64MapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed64Int64MapMessage &other) const;
    bool operator !=(const SimpleSFixed64Int64MapMessage &other) const;

    SimpleSFixed64Int64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed64Int64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed64Int64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed64Int64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleStringInt64MapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleStringInt64MapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 13,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QString, QtProtobuf::int64>;
    SimpleStringInt64MapMessage(QObject *parent = nullptr);
    ~SimpleStringInt64MapMessage() override;
    SimpleStringInt64MapMessage(const SimpleStringInt64MapMessage &other);
    SimpleStringInt64MapMessage &operator =(const SimpleStringInt64MapMessage &other);
    SimpleStringInt64MapMessage(SimpleStringInt64MapMessage &&other) noexcept;
    SimpleStringInt64MapMessage &operator =(SimpleStringInt64MapMessage &&other) noexcept;
    bool operator ==(const SimpleStringInt64MapMessage &other) const;
    bool operator !=(const SimpleStringInt64MapMessage &other) const;

    SimpleStringInt64MapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleStringInt64MapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleStringInt64MapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleStringInt64MapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt32ComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt32ComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 1,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint32, std::shared_ptr<ComplexMessage>>;
    SimpleSInt32ComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleSInt32ComplexMessageMapMessage() override;
    SimpleSInt32ComplexMessageMapMessage(const SimpleSInt32ComplexMessageMapMessage &other);
    SimpleSInt32ComplexMessageMapMessage &operator =(const SimpleSInt32ComplexMessageMapMessage &other);
    SimpleSInt32ComplexMessageMapMessage(SimpleSInt32ComplexMessageMapMessage &&other) noexcept;
    SimpleSInt32ComplexMessageMapMessage &operator =(SimpleSInt32ComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt32ComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleSInt32ComplexMessageMapMessage &other) const;

    SimpleSInt32ComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt32ComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt32ComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt32ComplexMessageMapMessage::MapFieldEntry m_mapField;
};


class  SimpleSInt64ComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSInt64ComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 2,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sint64, std::shared_ptr<ComplexMessage>>;
    SimpleSInt64ComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleSInt64ComplexMessageMapMessage() override;
    SimpleSInt64ComplexMessageMapMessage(const SimpleSInt64ComplexMessageMapMessage &other);
    SimpleSInt64ComplexMessageMapMessage &operator =(const SimpleSInt64ComplexMessageMapMessage &other);
    SimpleSInt64ComplexMessageMapMessage(SimpleSInt64ComplexMessageMapMessage &&other) noexcept;
    SimpleSInt64ComplexMessageMapMessage &operator =(SimpleSInt64ComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleSInt64ComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleSInt64ComplexMessageMapMessage &other) const;

    SimpleSInt64ComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSInt64ComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSInt64ComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSInt64ComplexMessageMapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt32ComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt32ComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 3,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int32, std::shared_ptr<ComplexMessage>>;
    SimpleInt32ComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleInt32ComplexMessageMapMessage() override;
    SimpleInt32ComplexMessageMapMessage(const SimpleInt32ComplexMessageMapMessage &other);
    SimpleInt32ComplexMessageMapMessage &operator =(const SimpleInt32ComplexMessageMapMessage &other);
    SimpleInt32ComplexMessageMapMessage(SimpleInt32ComplexMessageMapMessage &&other) noexcept;
    SimpleInt32ComplexMessageMapMessage &operator =(SimpleInt32ComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleInt32ComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleInt32ComplexMessageMapMessage &other) const;

    SimpleInt32ComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt32ComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt32ComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt32ComplexMessageMapMessage::MapFieldEntry m_mapField;
};


class  SimpleInt64ComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleInt64ComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 4,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::int64, std::shared_ptr<ComplexMessage>>;
    SimpleInt64ComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleInt64ComplexMessageMapMessage() override;
    SimpleInt64ComplexMessageMapMessage(const SimpleInt64ComplexMessageMapMessage &other);
    SimpleInt64ComplexMessageMapMessage &operator =(const SimpleInt64ComplexMessageMapMessage &other);
    SimpleInt64ComplexMessageMapMessage(SimpleInt64ComplexMessageMapMessage &&other) noexcept;
    SimpleInt64ComplexMessageMapMessage &operator =(SimpleInt64ComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleInt64ComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleInt64ComplexMessageMapMessage &other) const;

    SimpleInt64ComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleInt64ComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleInt64ComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleInt64ComplexMessageMapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt32ComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt32ComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 5,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint32, std::shared_ptr<ComplexMessage>>;
    SimpleUInt32ComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleUInt32ComplexMessageMapMessage() override;
    SimpleUInt32ComplexMessageMapMessage(const SimpleUInt32ComplexMessageMapMessage &other);
    SimpleUInt32ComplexMessageMapMessage &operator =(const SimpleUInt32ComplexMessageMapMessage &other);
    SimpleUInt32ComplexMessageMapMessage(SimpleUInt32ComplexMessageMapMessage &&other) noexcept;
    SimpleUInt32ComplexMessageMapMessage &operator =(SimpleUInt32ComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt32ComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleUInt32ComplexMessageMapMessage &other) const;

    SimpleUInt32ComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt32ComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt32ComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt32ComplexMessageMapMessage::MapFieldEntry m_mapField;
};


class  SimpleUInt64ComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleUInt64ComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 6,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::uint64, std::shared_ptr<ComplexMessage>>;
    SimpleUInt64ComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleUInt64ComplexMessageMapMessage() override;
    SimpleUInt64ComplexMessageMapMessage(const SimpleUInt64ComplexMessageMapMessage &other);
    SimpleUInt64ComplexMessageMapMessage &operator =(const SimpleUInt64ComplexMessageMapMessage &other);
    SimpleUInt64ComplexMessageMapMessage(SimpleUInt64ComplexMessageMapMessage &&other) noexcept;
    SimpleUInt64ComplexMessageMapMessage &operator =(SimpleUInt64ComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleUInt64ComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleUInt64ComplexMessageMapMessage &other) const;

    SimpleUInt64ComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleUInt64ComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleUInt64ComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleUInt64ComplexMessageMapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed32ComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed32ComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 7,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed32, std::shared_ptr<ComplexMessage>>;
    SimpleFixed32ComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleFixed32ComplexMessageMapMessage() override;
    SimpleFixed32ComplexMessageMapMessage(const SimpleFixed32ComplexMessageMapMessage &other);
    SimpleFixed32ComplexMessageMapMessage &operator =(const SimpleFixed32ComplexMessageMapMessage &other);
    SimpleFixed32ComplexMessageMapMessage(SimpleFixed32ComplexMessageMapMessage &&other) noexcept;
    SimpleFixed32ComplexMessageMapMessage &operator =(SimpleFixed32ComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed32ComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleFixed32ComplexMessageMapMessage &other) const;

    SimpleFixed32ComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed32ComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed32ComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed32ComplexMessageMapMessage::MapFieldEntry m_mapField;
};


class  SimpleFixed64ComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleFixed64ComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 8,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::fixed64, std::shared_ptr<ComplexMessage>>;
    SimpleFixed64ComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleFixed64ComplexMessageMapMessage() override;
    SimpleFixed64ComplexMessageMapMessage(const SimpleFixed64ComplexMessageMapMessage &other);
    SimpleFixed64ComplexMessageMapMessage &operator =(const SimpleFixed64ComplexMessageMapMessage &other);
    SimpleFixed64ComplexMessageMapMessage(SimpleFixed64ComplexMessageMapMessage &&other) noexcept;
    SimpleFixed64ComplexMessageMapMessage &operator =(SimpleFixed64ComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleFixed64ComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleFixed64ComplexMessageMapMessage &other) const;

    SimpleFixed64ComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleFixed64ComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleFixed64ComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleFixed64ComplexMessageMapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed32ComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 9,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed32, std::shared_ptr<ComplexMessage>>;
    SimpleSFixed32ComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleSFixed32ComplexMessageMapMessage() override;
    SimpleSFixed32ComplexMessageMapMessage(const SimpleSFixed32ComplexMessageMapMessage &other);
    SimpleSFixed32ComplexMessageMapMessage &operator =(const SimpleSFixed32ComplexMessageMapMessage &other);
    SimpleSFixed32ComplexMessageMapMessage(SimpleSFixed32ComplexMessageMapMessage &&other) noexcept;
    SimpleSFixed32ComplexMessageMapMessage &operator =(SimpleSFixed32ComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed32ComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleSFixed32ComplexMessageMapMessage &other) const;

    SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry m_mapField;
};


class  SimpleSFixed64ComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 10,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QtProtobuf::sfixed64, std::shared_ptr<ComplexMessage>>;
    SimpleSFixed64ComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleSFixed64ComplexMessageMapMessage() override;
    SimpleSFixed64ComplexMessageMapMessage(const SimpleSFixed64ComplexMessageMapMessage &other);
    SimpleSFixed64ComplexMessageMapMessage &operator =(const SimpleSFixed64ComplexMessageMapMessage &other);
    SimpleSFixed64ComplexMessageMapMessage(SimpleSFixed64ComplexMessageMapMessage &&other) noexcept;
    SimpleSFixed64ComplexMessageMapMessage &operator =(SimpleSFixed64ComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleSFixed64ComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleSFixed64ComplexMessageMapMessage &other) const;

    SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry m_mapField;
};


class  SimpleStringComplexMessageMapMessage : public QObject
{
    Q_OBJECT
    Q_PROTOBUF_OBJECT
    Q_PROPERTY(qtprotobufnamespace::tests::SimpleStringComplexMessageMapMessage::MapFieldEntry mapField READ mapField WRITE setMapField NOTIFY mapFieldChanged SCRIPTABLE true)

public:
    enum QtProtobufFieldEnum {
        MapFieldProtoFieldNumber = 13,
    };
    Q_ENUM(QtProtobufFieldEnum)

    using MapFieldEntry = QHash<QString, std::shared_ptr<ComplexMessage>>;
    SimpleStringComplexMessageMapMessage(QObject *parent = nullptr);
    ~SimpleStringComplexMessageMapMessage() override;
    SimpleStringComplexMessageMapMessage(const SimpleStringComplexMessageMapMessage &other);
    SimpleStringComplexMessageMapMessage &operator =(const SimpleStringComplexMessageMapMessage &other);
    SimpleStringComplexMessageMapMessage(SimpleStringComplexMessageMapMessage &&other) noexcept;
    SimpleStringComplexMessageMapMessage &operator =(SimpleStringComplexMessageMapMessage &&other) noexcept;
    bool operator ==(const SimpleStringComplexMessageMapMessage &other) const;
    bool operator !=(const SimpleStringComplexMessageMapMessage &other) const;

    SimpleStringComplexMessageMapMessage::MapFieldEntry mapField() const {
        return m_mapField;
    }

    SimpleStringComplexMessageMapMessage::MapFieldEntry &mapField() {
        return m_mapField;
    }

    void setMapField(const SimpleStringComplexMessageMapMessage::MapFieldEntry &mapField);
    static void registerTypes();

Q_SIGNALS:
    void mapFieldChanged();

private:
    SimpleStringComplexMessageMapMessage::MapFieldEntry m_mapField;
};

} // namespace qtprotobufnamespace::tests

Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt32StringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt64StringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt32StringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt64StringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt32StringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt64StringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed32StringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed64StringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed32StringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed64StringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleStringStringMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt32SInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt64SInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt32SInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt64SInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt32SInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt64SInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed32SInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed64SInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed32SInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed64SInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleStringSInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt32SInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt64SInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt32SInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt64SInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt32SInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt64SInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed32SInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed64SInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed32SInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed64SInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleStringSInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt32UInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt64UInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt32UInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt64UInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt32UInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt64UInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed32UInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed64UInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed32UInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed64UInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleStringUInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt32UInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt64UInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt32UInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt64UInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt32UInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt64UInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed32UInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed64UInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed32UInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed64UInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleStringUInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt32Int32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt64Int32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt32Int32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt64Int32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt32Int32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt64Int32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed32Int32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed64Int32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed32Int32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed64Int32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleStringInt32MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt32Int64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt64Int64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt32Int64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt64Int64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt32Int64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt64Int64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed32Int64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed64Int64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed32Int64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed64Int64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleStringInt64MapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt32ComplexMessageMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSInt64ComplexMessageMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt32ComplexMessageMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleInt64ComplexMessageMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt32ComplexMessageMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleUInt64ComplexMessageMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed32ComplexMessageMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleFixed64ComplexMessageMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed32ComplexMessageMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleSFixed64ComplexMessageMapMessage)
Q_DECLARE_METATYPE(qtprotobufnamespace::tests::SimpleStringComplexMessageMapMessage)
#endif // Q_PROTOBUF_mapmessages_H
